Source code for energy_analysis.failure_reliability

"""Apply reliability databases without pooling incompatible populations or units."""

from __future__ import annotations

import argparse
import json
from pathlib import Path
from typing import Any

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from energy_data_retrieval.failure_database import (
    database_coverage,
    load_failure_database,
    source_catalogue,
)
from energy_methods.failure_rates import BetaDemand, GammaRate, LifetimeModel, estimate_rate

REFERENCE_IDS = (
    "inl_2021_component_reliability",
    "klise_2018_pv_failures",
    "carroll_2016_offshore_failures",
    "backblaze_drive_stats",
)


[docs] def analyse_database() -> pd.DataFrame: """Evaluate every usable record using explicit, separate screening missions. NRC: 24 operating hours (1 hour for first-hour modes), one demand, or 100 feet of pipe for 24 hours. PV: a one-year fault-free interval from zero (365 days), conditional-positive normal when applicable. Wind: one turbine-year. Drives: 365 observed drive-days. These are scenario inputs, not new field measurements. No technology or OEM ranking across sources. """ results = [] for row in load_failure_database().to_dict("records"): kind, basis = row["distribution"], row["basis"] result = { key: row[key] for key in ( "record_id", "source_id", "device", "population", "failure_mode", "basis", "distribution", "evidence", ) } if kind in {"gamma_rate", "beta_probability"}: if kind == "gamma_rate": model = GammaRate(row["parameter1"], row["parameter2"]) exposure = ( 2400 if basis == "foot_hour" else (1 if "<1H" in row["failure_mode"] else 24) ) probability = model.probability_at_least_one(exposure) expected = model.expected_failures(exposure) else: demand_model = BetaDemand(row["parameter1"], row["parameter2"]) exposure = 1 probability = demand_model.probability_at_least_one(exposure) expected = demand_model.mean result.update( mission_exposure=exposure, probability_at_least_one=probability, expected_events=expected, parameter_mean=row["mean"], parameter_p05=row["p05"], parameter_p95=row["p95"], interval_kind="published industry distribution, central 90%", ) elif kind == "point_rate": result.update( mission_exposure=1, expected_events=row["mean"], parameter_mean=row["mean"], interval_kind="not available", ) # A mean repair-event frequency alone does not establish Poisson event timing. elif kind == "observed_count": fit = estimate_rate(int(row["failures"]), row["exposure"]) result.update( mission_exposure=365, expected_events=fit.rate * 365, parameter_mean=fit.rate, parameter_p025=fit.lower, parameter_p975=fit.upper, probability_at_least_one=float(-np.expm1(-fit.rate * 365)), interval_kind="Poisson count, central 95%; homogeneous-rate assumption", failures=fit.failures, exposure=fit.exposure, ) else: lifetime_kind = kind.removesuffix("_lifetime") lifetime = LifetimeModel(lifetime_kind, row["parameter1"], row["parameter2"]) horizon = {"hour": 8760, "day": 365, "year": 1}[basis] result.update( mission_exposure=horizon, probability_at_least_one=lifetime.conditional_failure(0, horizon), interval_kind="fit uncertainty unavailable; conditional fault interval", ) results.append(result) return pd.DataFrame(results)
[docs] def wind_maintenance_budget( *, turbines: int = 100, cost_per_event: dict[str, float] | None = None ) -> pd.DataFrame: """Expected annual direct repair budget under explicitly supplied scenario costs. Default EUR/event: minor 500, major 5000, replacement 50000, unknown 1500. No vessel costs, lost energy, discounting, inflation or correlated outages. Published cost classes are historical; these values are illustrative inputs. """ if isinstance(turbines, bool) or int(turbines) != turbines or turbines <= 0: raise ValueError("turbines must be a positive integer") costs = ( cost_per_event if cost_per_event is not None else { "Minor Repair": 500.0, "Major Repair": 5000.0, "Major Replacement": 50000.0, "No Cost Data": 1500.0, } ) data = load_failure_database("wind_2016") if set(costs) != set(data.failure_mode) or any( not np.isfinite(v) or v < 0 for v in costs.values() ): raise ValueError("Provide finite nonnegative costs for every published repair class") data["expected_annual_events"] = data["mean"] * turbines data["assumed_eur_per_event"] = data.failure_mode.map(costs) data["expected_annual_cost_eur"] = data.expected_annual_events * data.assumed_eur_per_event return data
[docs] def plot_failure_analysis() -> plt.Figure: """Four source-specific views; units and statistical interpretations stay separate.""" fig, axes = plt.subplots(2, 2, figsize=(14, 10), layout="constrained") nrc = load_failure_database("nrc_2020").set_index("failure_mode") selected = [ code for code in ( "MDP-FTR-NR", "EDG-FTR>1H", "BCH-FTOP", "INV-FTOP", "TFM-FTOP", "CHL-FTR-NR", "FAN-FTR-NR", ) if code in nrc.index ] sub = nrc.loc[selected].sort_values("mean") ax = axes[0, 0] ax.errorbar( sub["mean"] * 1e6, np.arange(len(sub)), xerr=np.vstack(((sub["mean"] - sub.p05) * 1e6, (sub.p95 - sub["mean"]) * 1e6)), fmt="o", color="#146b8c", capsize=3, ) ax.set_yticks(np.arange(len(sub)), sub.index) ax.set( xlabel="Failures / million relevant operating hours", title="Industrial equipment: NRC population\nPublished 5th-95th distribution percentiles", ) wind = load_failure_database("wind_2016") pivot = wind.pivot(index="device", columns="failure_mode", values="mean") pivot = pivot.loc[pivot.sum(axis=1).sort_values().tail(8).index] pivot.plot.barh(stacked=True, ax=axes[0, 1], color=["#933f54", "#e79b43", "#167b89", "#b4c6cb"]) axes[0, 1].set( xlabel="Recorded repair events / turbine-year", ylabel="", title="Offshore wind: eight most frequent subsystems", ) axes[0, 1].legend(fontsize=7, loc="lower right") pv = load_failure_database("pvrom_2018") wanted = { "ID_TEP_module (Southwest)": "Module", "ID_TEP_Dccombiner (Southwest)": "DC combiner", "ID_TEP_ACdisconnect (Southwest)": "AC disconnect", "ID_TEP_HV_Transformer (Southwest)": "HV transformer", } age_days = np.linspace(0, 5 * 365, 151) for row in pv[pv.source_row.isin(wanted)].to_dict("records"): model = LifetimeModel("weibull", row["parameter1"], row["parameter2"]) axes[1, 0].plot( age_days / 365, 100 * -np.expm1(model.log_survival(age_days)), label=wanted[row["source_row"]], ) axes[1, 0].set( xlabel="Fault interval (years)", ylabel="Modelled event probability (%)", title="PVROM historical portfolio fits\nExtrapolation; not a universal device lifetime", ) axes[1, 0].legend(fontsize=8) drives = load_failure_database("backblaze_2013").nlargest(8, "exposure") estimates = [ estimate_rate(int(r["failures"]), float(r["exposure"])) for r in drives.to_dict("records") ] means = np.array([r.rate for r in estimates]) * 36500 lower = np.array([r.lower for r in estimates]) * 36500 upper = np.array([r.upper for r in estimates]) * 36500 axes[1, 1].errorbar( means, np.arange(len(drives)), xerr=[means - lower, upper - means], fmt="o", capsize=3, color="#933f54", ) axes[1, 1].set_yticks(np.arange(len(drives)), drives.population) axes[1, 1].set( xlabel="Annualized recorded failures per 100 drive-years", title="Backblaze 2013: largest observed exposures\n95% Poisson intervals; historical fleet", ) for ax in axes.flat: ax.spines[["top", "right"]].set_visible(False) ax.grid(axis="x", alpha=0.15) fig.suptitle("Failure-rate evidence across equipment classes", fontsize=18) return fig
[docs] def run_study(output: Path) -> dict[str, Any]: """Write the normalized database, results, audit and figures under output.""" output.mkdir(parents=True, exist_ok=True) database = load_failure_database(include_flagged=True) estimates = analyse_database() budget = wind_maintenance_budget() # Flatten audit flags only for Parquet; JSON preserves list structure. database.to_json(output / "failure_database.json", orient="records", indent=2) database.assign(quality_flags=database.quality_flags.map(";".join)).to_parquet( output / "failure_database.parquet", index=False ) estimates.to_csv(output / "failure_estimates.csv", index=False) budget.to_csv(output / "wind_budget_scenario.csv", index=False) source_catalogue().to_json(output / "sources.json", orient="records", indent=2) figure = plot_failure_analysis() figure.savefig(output / "failure_reliability.png", dpi=160) plt.close(figure) summary = { "coverage": database_coverage().to_dict("records"), "evaluated_records": len(estimates), "wind_100_turbines_scenario_events_per_year": float(budget.expected_annual_events.sum()), "wind_100_turbines_scenario_direct_eur_per_year": float( budget.expected_annual_cost_eur.sum() ), "assumptions": "See docs/failure-rates.md. Sources are not interchangeable.", } (output / "summary.json").write_text(json.dumps(summary, indent=2) + "\n") return summary
[docs] def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--output", type=Path, default=Path("artifacts/failure-reliability")) args = parser.parse_args() print(json.dumps(run_study(args.output), indent=2))
if __name__ == "__main__": main()