--- name: reliability-analysis-78f9fc9bc951 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" graph: domains: [domain:electrical-engineering] skillAreas: [skill-area:hardware-abstraction-layer, skill-area:device-drivers, skill-area:firmware-development] roles: [role:embedded-engineer, role:systems-integration-engineer] --- # 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_fails.add_child(FaultTreeNode("AC Power Loss", probability=0.01)) primary_fails.add_child(FaultTreeNode("UPS Fails", probability=0.001)) backup_fails = FaultTreeNode("Backup Supply Fails", probability=0.005) top.add_child(primary_fails) top.add_child(backup_fails) system_probability = top.calculate_probability() print(f"Top event probability: {system_probability:.6f}") ``` ### Accelerated Life Test Analysis ```python 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) for r in failure_rates] # Linear regression: ln(rate) = A + Ea/(k*T) slope, intercept = np.polyfit(inv_temps, ln_rates, 1) self.activation_energy = slope * self.k_boltzmann return self.activation_energy # Example usage model = ArrheniusModel() # Multi-temperature test results test_temps = [85, 105, 125] # Celsius failure_rates = [0.001, 0.005, 0.02] # failures per 1000 hours ea = model.estimate_activation_energy(test_temps, failure_rates) print(f"Estimated activation energy: {ea:.2f} eV") # Project to use conditions af = model.acceleration_factor(125, 55, ea) use_life = 2000 * af # If 2000 hours at 125C print(f"Acceleration factor: {af:.1f}x") print(f"Projected life at 55C: {use_life:.0f} hours") ``` ## 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 --- Source attribution: a5c-ai Original project: https://github.com/a5c-ai/babysitter/blob/feb68abe397acc14f32b34984975c48fedba2b33/library/specializations/domains/science/electrical-engineering/skills/reliability-analysis/SKILL.md License: MIT License information: https://opensource.org/license/mit Original upstream instructions; downloaded from Dave AI. ## Upstream license notice # MIT License Copyright (c) 2025 A5C AI Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # Dave AI resource metadata Creator / publisher: a5c-ai Original project: https://github.com/a5c-ai/babysitter/blob/feb68abe397acc14f32b34984975c48fedba2b33/library/specializations/domains/science/electrical-engineering/skills/reliability-analysis/SKILL.md Attribution basis: Source repository record Fields of work: Data & Analytics, Development & Engineering, Product Management Roles: Backend Developer, Data Analyst, ML / AI Engineer, Product Manager, QA / Test Engineer Specialties: Backend, Testing Tools: Jinja2, Lifelines, Matplotlib, Numpy, Openpyxl, Pandas, Scipy, Surpyval Country applicability: Country not specified Classification basis: Source catalog labels Instruction SHA-256: d2d445aaa244326b58500bc59f02ed6a4e833cf99b0e72937a67bd04c0f71ffa