Source code for energy_methods.wind_shared_outage

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