"""Finite-fleet wind outage exposure with independent and shared-event scenarios.
This is a transparent, single-period probability mixture, NOT an inferred blade
failure rate, a causal diagnosis, or a field-calibrated availability prediction.
Background: Mosleh et al. (1998), NUREG/CR-5485, guidelines for evaluating
common-cause failures in probabilistic risk assessment. This illustrative
mixture is NOT an implementation of a calibrated NRC alpha/beta-factor model.
"""
from __future__ import annotations
import math
from dataclasses import dataclass
[docs]
@dataclass(frozen=True)
class WindOutageExposure:
"""Scenario distribution for unavailable turbines in ONE assessment period.
Probabilities, p95/p99, and energy are conditional on stated hypothetical
inputs. The MWh values assume each unavailable turbine misses the whole
stated window at one constant counterfactual capacity factor.
"""
turbine_count: int
rated_power_mw: float
capacity_factor: float
window_hours: float
probability_by_unavailable: tuple[float, ...]
[docs]
def at_least(self, unavailable_turbines: int) -> float:
"""P(K >= threshold), including the threshold (K=unavailable units)."""
if isinstance(unavailable_turbines, bool) or not isinstance(unavailable_turbines, int):
raise ValueError("unavailable_turbines must be an integer")
if unavailable_turbines <= 0:
return 1.0
if unavailable_turbines > self.turbine_count:
return 0.0
return math.fsum(self.probability_by_unavailable[unavailable_turbines:])
[docs]
def unavailable_quantile(self, quantile: float) -> int:
"""Left-continuous discrete quantile of turbine unavailability."""
if not math.isfinite(quantile) or not 0 <= quantile <= 1:
raise ValueError("quantile must be finite in [0, 1]")
cumulative = 0.0
for units, probability in enumerate(self.probability_by_unavailable):
cumulative += probability
if cumulative >= quantile - 1e-14:
return units
return self.turbine_count
@property
def expected_unavailable(self) -> float:
"""Mean number of simultaneously unavailable turbines."""
return math.fsum(k * p for k, p in enumerate(self.probability_by_unavailable))
@property
def per_turbine_exposure_mwh(self) -> float:
"""Synthetic full-window energy exposure if one turbine is unavailable."""
return self.rated_power_mw * self.capacity_factor * self.window_hours
@property
def expected_exposure_mwh(self) -> float:
"""Illustrative expected MWh at risk, NOT observed curtailed generation."""
return self.expected_unavailable * self.per_turbine_exposure_mwh
[docs]
def exposure_quantile_mwh(self, quantile: float) -> float:
"""Illustrative MWh-at-risk quantile under full-window unavailability."""
return self.unavailable_quantile(quantile) * self.per_turbine_exposure_mwh
def _binomial_pmf(n: int, p: float) -> tuple[float, ...]:
"""Exact finite-n Bernoulli distribution, with explicit degenerate endpoints."""
if p == 0:
return (1.0,) + (0.0,) * n
if p == 1:
return (0.0,) * n + (1.0,)
return tuple(math.comb(n, k) * p**k * (1 - p) ** (n - k) for k in range(n + 1))
[docs]
def screen_wind_shared_outage(
*,
turbine_count: int,
rated_power_mw: float,
independent_probability: float,
shared_event_probability: float = 0.0,
shared_affected_turbines: int = 0,
capacity_factor: float = 0.45,
window_hours: float = 24.0,
) -> WindOutageExposure:
"""Mixture of independent turbine unavailability and a shared outage.
Model: with probability q a shared event removes exactly m distinct units;
each of the remaining n-m units independently fails with probability p.
Without a shared event all n units independently fail with probability p.
Thus P(K=k)=(1-q)Bin(n,p)[k] + q Bin(n-m,p)[k-m].
p and q are assessment-window **scenario probabilities**, not event rates,
not estimated from the He Dreiht blade incident. All units are identical;
failures and shutdowns last the full assumed window. This is not a turbine
structural-integrity model, a reliability certification, or a safety plan.
"""
if (
isinstance(turbine_count, bool)
or not isinstance(turbine_count, int)
or not 1 <= turbine_count <= 500
):
raise ValueError("turbine_count must be an integer in [1, 500]")
if (
isinstance(shared_affected_turbines, bool)
or not isinstance(shared_affected_turbines, int)
or not 0 <= shared_affected_turbines <= turbine_count
):
raise ValueError("shared_affected_turbines must be an integer in [0, turbine_count]")
for label, value in (
("independent_probability", independent_probability),
("shared_event_probability", shared_event_probability),
("capacity_factor", capacity_factor),
):
if not math.isfinite(value) or not 0 <= value <= 1:
raise ValueError(f"{label} must be finite in [0, 1]")
if not math.isfinite(rated_power_mw) or rated_power_mw <= 0:
raise ValueError("rated_power_mw must be finite and positive")
if not math.isfinite(window_hours) or window_hours <= 0:
raise ValueError("window_hours must be finite and positive")
if shared_event_probability > 0 and shared_affected_turbines == 0:
raise ValueError("shared events require at least one affected turbine")
independent = _binomial_pmf(turbine_count, independent_probability)
remaining = _binomial_pmf(turbine_count - shared_affected_turbines, independent_probability)
q = shared_event_probability
weights = [p * (1 - q) for p in independent]
for i, probability in enumerate(remaining):
weights[shared_affected_turbines + i] += q * probability
total = math.fsum(weights)
return WindOutageExposure(
turbine_count=turbine_count,
rated_power_mw=rated_power_mw,
capacity_factor=capacity_factor,
window_hours=window_hours,
probability_by_unavailable=tuple(weight / total for weight in weights),
)