"""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()