reliability-analysis

name	reliability-analysis
description	Component and system reliability prediction and analysis skill with MTBF/MTTF calculations, failure rate databases, FMEA/FMECA support, fault tree analysis, and accelerated life testing data analysis.
allowed-tools	Read, Grep, Write, Bash, Edit, Glob
category	Testing and Validation
backlog-id	SK-020
metadata	{"author":"babysitter-sdk","version":"1.0.0"}

Reliability Analysis Skill

Component and system reliability prediction and analysis for electronic hardware.

Purpose

This skill provides comprehensive capabilities for predicting and analyzing the reliability of electronic components and systems. It supports industry-standard reliability methodologies, failure rate calculations, and life testing data analysis.

Capabilities

MTBF/MTTF Calculations

• Mean Time Between Failures (MTBF) for repairable systems
• Mean Time To Failure (MTTF) for non-repairable components
• Series and parallel system reliability modeling
• Redundancy calculations (active, standby, k-out-of-n)
• Mission reliability vs operational availability

Failure Rate Databases

• MIL-HDBK-217F failure rate predictions
• Telcordia SR-332 methodology
• FIDES reliability methodology
• IEC 62380 electronic component reliability
• Custom component database management

Derating Analysis

• Component stress ratio calculations
• Temperature derating curves
• Voltage and power derating
• Derating guideline compliance (NAVSEA, JPL, ESA)
• Stress analysis documentation

FMEA/FMECA Support

• Failure Mode and Effects Analysis facilitation
• Criticality analysis (CA) calculations
• Risk Priority Number (RPN) computation
• Severity, occurrence, detection ratings
• FMEA worksheet generation
• Action tracking and verification

Reliability Block Diagram Analysis

• RBD construction and visualization
• Series, parallel, and complex configurations
• Active and standby redundancy modeling
• Common cause failure analysis
• System reliability calculation

Fault Tree Analysis (FTA)

• Fault tree construction (AND, OR, k-of-n gates)
• Minimal cut set identification
• Top event probability calculation
• Importance measures (Birnbaum, Fussell-Vesely)
• Common cause failure modeling

Accelerated Life Testing Data Analysis

• Arrhenius model for temperature acceleration
• Eyring model for multi-stress acceleration
• Inverse power law for voltage/mechanical stress
• Acceleration factor calculation
• Life projection to use conditions

Weibull Distribution Fitting

• Two-parameter and three-parameter Weibull
• Maximum Likelihood Estimation (MLE)
• Probability plotting
• Goodness-of-fit testing
• Confidence interval estimation
• B-life calculations (B1, B10, B50)

Thermal Derating Curves

• Junction temperature estimation
• Thermal resistance modeling
• Safe operating area verification
• Thermal runaway analysis
• Heatsink selection guidance

Prerequisites

Installation

pip install numpy scipy pandas matplotlib reliability weibull

Optional Dependencies

# For advanced reliability modeling
pip install surpyval lifelines

# For report generation
pip install jinja2 openpyxl

Usage Patterns

MTBF Calculation with MIL-HDBK-217

import numpy as np

class MIL217Calculator:
    """MIL-HDBK-217F failure rate calculator"""

    # Base failure rates (per 10^6 hours) - simplified examples
    BASE_RATES = {
        'resistor_film': 0.0037,
        'capacitor_ceramic': 0.012,
        'capacitor_electrolytic': 0.12,
        'diode_general': 0.024,
        'transistor_bipolar': 0.074,
        'ic_digital': 0.16,
        'ic_linear': 0.21,
        'inductor': 0.0017,
        'connector_pin': 0.00066,
        'pcb_layer': 0.00042,
    }

    # Temperature factors (simplified)
    @staticmethod
    def temp_factor(temp_c: float, component_type: str) -> float:
        if 'capacitor_electrolytic' in component_type:
            return np.exp((temp_c - 25) / 15)
        return np.exp((temp_c - 25) / 20)

    # Environment factors
    ENV_FACTORS = {
        'ground_benign': 1.0,
        'ground_fixed': 2.0,
        : ,
        : ,
        : ,
        : ,
    }

     () -> :
        
        base_rate = .BASE_RATES.get(component_type, )
        temp_factor = .temp_factor(temp_c, component_type)
        env_factor = .ENV_FACTORS.get(environment, )

         base_rate * temp_factor * env_factor * quantity

     () -> :
        
        total_fr = (c[]  c  components)
        mtbf =  / total_fr  

         {
            : total_fr,
            : mtbf,
            : mtbf / ,
            : components
        }


calc = MIL217Calculator()
components = [
    {: , : , : },
    {: , : , : },
    {: , : , : },
]

 comp  components:
    comp[] = calc.calculate_component_fr(
        comp[], comp[], , comp[]
    )

result = calc.calculate_system_mtbf(components)
()

Weibull Analysis

from reliability.Fitters import Fit_Weibull_2P
from reliability.Probability_plotting import Weibull_probability_plot
import matplotlib.pyplot as plt

# Life test data (hours to failure)
failures = [1200, 1500, 1800, 2100, 2400, 2800, 3200, 3800, 4500, 5500]
censored = [6000, 6000, 6000]  # Units still running at test end

# Fit Weibull distribution
fit = Fit_Weibull_2P(
    failures=failures,
    right_censored=censored,
    show_probability_plot=False
)

print(f"Beta (shape): {fit.beta:.3f}")
print(f"Eta (scale): {fit.eta:.1f} hours")
print(f"B10 Life: {fit.distribution.quantile(0.1):.1f} hours")
print(f"B50 Life: {fit.distribution.quantile(0.5):.1f} hours")
print(f"Mean Life: {fit.distribution.mean:.1f} hours")

# Reliability at specific time
time = 2000  # hours
R_2000 = fit.distribution.SF(time)
print(f"Reliability at  hours:  (%)")

Fault Tree Analysis

from typing import List, Dict

class FaultTreeNode:
    def __init__(self, name: str, gate_type: str = None, probability: float = None):
        self.name = name
        self.gate_type = gate_type  # 'AND', 'OR', 'VOTE'
        self.probability = probability  # For basic events
        self.children: List['FaultTreeNode'] = []
        self.k = None  # For k-out-of-n voting gates

    def add_child(self, child: 'FaultTreeNode'):
        self.children.append(child)

    def calculate_probability(self) -> float:
        if self.probability is not None:
            return self.probability

        child_probs = [c.calculate_probability() for c in self.children]

        if self.gate_type == 'AND':
            result = 1.0
             p  child_probs:
                result *= p
             result

         .gate_type == :
            result = 
             p  child_probs:
                result *= ( - p)
              - result

         .gate_type == :
            
             itertools  combinations
             functools  reduce
             operator

            n = (child_probs)
            k = .k
            prob = 

             i  (k, n + ):
                 combo  combinations((n), i):
                    term = 
                     j  (n):
                         j  combo:
                            term *= child_probs[j]
                        :
                            term *= ( - child_probs[j])
                    prob += term
             prob


top = FaultTreeNode(, )

primary_fails = FaultTreeNode(, )
primary_fails.add_child(FaultTreeNode(, probability=))
primary_fails.add_child(FaultTreeNode(, probability=))

backup_fails = FaultTreeNode(, probability=)

top.add_child(primary_fails)
top.add_child(backup_fails)

system_probability = top.calculate_probability()
()

Accelerated Life Test Analysis

import numpy as np
from scipy.optimize import curve_fit

class ArrheniusModel:
    """Arrhenius acceleration model for temperature stress"""

    def __init__(self):
        self.activation_energy = None  # eV
        self.k_boltzmann = 8.617e-5  # eV/K

    def acceleration_factor(self, temp_test: float, temp_use: float,
                           activation_energy: float) -> float:
        """Calculate acceleration factor between test and use conditions"""
        temp_test_k = temp_test + 273.15
        temp_use_k = temp_use + 273.15

        af = np.exp((activation_energy / self.k_boltzmann) *
                    (1/temp_use_k - 1/temp_test_k))
        return af

    def estimate_activation_energy(self, temps: List[float],
                                   failure_rates: List[float]) -> float:
        """Estimate activation energy from multi-temperature test data"""
        temps_k = [t + 273.15 for t in temps]
        inv_temps = [1/t for t in temps_k]
        ln_rates = [np.log(r)  r  failure_rates]

        
        slope, intercept = np.polyfit(inv_temps, ln_rates, )
        .activation_energy = slope * .k_boltzmann
         .activation_energy


model = ArrheniusModel()


test_temps = [, , ]  
failure_rates = [, , ]  

ea = model.estimate_activation_energy(test_temps, failure_rates)
()


af = model.acceleration_factor(, , ea)
use_life =  * af  
()
()

Usage Guidelines

When to Use This Skill

• New product reliability predictions
• Design for reliability (DfR) activities
• Warranty cost projections
• FMEA and FMECA development
• Life test planning and analysis
• Field failure analysis support

Best Practices

1. Use appropriate failure rate models for the application environment
2. Consider temperature derating for all components
3. Document all assumptions in reliability predictions
4. Validate predictions with field data when available
5. Update failure rates based on actual performance
6. Include manufacturing defects in early-life reliability models

Process Integration

• ee-environmental-testing (life test analysis)
• ee-hardware-validation (reliability verification)
• ee-dfm-review (reliability design reviews)

Dependencies

• reliability: Python reliability engineering library
• scipy: Statistical analysis
• numpy: Numerical computations

References

• MIL-HDBK-217F Reliability Prediction
• FIDES Reliability Methodology Guide
• IEEE 1413 Methodology for Reliability Prediction
• SAE JA1000 Reliability Program Standard