reliability-analysis

What this skill does

# 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
```bash
pip install numpy scipy pandas matplotlib reliability weibull
```

### Optional Dependencies
```bash
# For advanced reliability modeling
pip install surpyval lifelines

# For report generation
pip install jinja2 openpyxl
```

## Usage Patterns

### MTBF Calculation with MIL-HDBK-217
```python
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,
        'ground_mobile': 5.0,
        'airborne_inhabited': 4.0,
        'airborne_uninhabited': 8.0,
        'space_flight': 0.5,
    }

    def calculate_component_fr(self, component_type: str, temp_c: float,
                                environment: str, quantity: int = 1) -> float:
        """Calculate failure rate for component type"""
        base_rate = self.BASE_RATES.get(component_type, 0.1)
        temp_factor = self.temp_factor(temp_c, component_type)
        env_factor = self.ENV_FACTORS.get(environment, 2.0)

        return base_rate * temp_factor * env_factor * quantity

    def calculate_system_mtbf(self, components: list) -> dict:
        """Calculate system MTBF from component list"""
        total_fr = sum(c['failure_rate'] for c in components)
        mtbf = 1e6 / total_fr  # Hours

        return {
            'total_failure_rate': total_fr,
            'mtbf_hours': mtbf,
            'mtbf_years': mtbf / 8760,
            'components': components
        }

# Example usage
calc = MIL217Calculator()
components = [
    {'type': 'resistor_film', 'qty': 100, 'temp': 55},
    {'type': 'capacitor_ceramic', 'qty': 50, 'temp': 55},
    {'type': 'ic_digital', 'qty': 10, 'temp': 65},
]

for comp in components:
    comp['failure_rate'] = calc.calculate_component_fr(
        comp['type'], comp['temp'], 'ground_fixed', comp['qty']
    )

result = calc.calculate_system_mtbf(components)
print(f"System MTBF: {result['mtbf_hours']:.0f} hours ({result['mtbf_years']:.1f} years)")
```

### Weibull Analysis
```python
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 {time} hours: {R_2000:.4f} ({R_2000*100:.2f}%)")
```

### Fault Tree Analysis
```python
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
            for p in child_probs:
                result *= p
            return result

        elif self.gate_type == 'OR':
            result = 1.0
            for p in child_probs:
                result *= (1 - p)
            return 1 - result

        elif self.gate_type == 'VOTE':
            # k-out-of-n gate
            from itertools import combinations
            from functools import reduce
            import operator

            n = len(child_probs)
            k = self.k
            prob = 0

            for i in range(k, n + 1):
                for combo in combinations(range(n), i):
                    term = 1.0
                    for j in range(n):
                        if j in combo:
                            term *= child_probs[j]
                        else:
                            term *= (1 - child_probs[j])
                    prob += term
            return prob

# Example: Power supply failure fault tree
top = FaultTreeNode("Power Supply Fails", "OR")

primary_fails = FaultTreeNode("Primary Supply Fails", "AND")
primary_fail