api581-engine 0.1.4__py3-none-any.whl

api581/pool_fire.py

@@ -0,0 +1,273 @@
+"""Pool fire radiation, with printed and independently integrated geometry bases."""
+import math
+from typing import Annotated, Literal
+from pydantic import Field
+from .core import Model, NonNegative, Positive, Fraction, calculation, ensure
+from .effects import PoolBurning, pool_burning, PoolArea, pool_area
+
+Tilt = Annotated[float,Field(ge=0,lt=math.pi/2,strict=True,allow_inf_nan=False)]
+EquationBasis = Literal["api581_printed", "geometry_checked"]
+DistanceConvention = Literal["printed_surface_ratio", "surface_to_axis"]
+
+
+class WaterPressure(Model):
+    ambient_temperature_k: Positive
+    relative_humidity_fraction: Fraction
+    ambient_pressure_pa_abs: Positive = 101325
+
+
+@calculation("properties/water-partial-pressure", "Water partial pressure for radiation attenuation", WaterPressure,
+             ["Part3 eq(3.141), Annex3.B C20/C21; PDF pp552,648"],
+             limitations=["Uses printed1.013kPa,5328K and14.4114. RH in this equation is percent; public fraction is multiplied by100. Rejects pressure above declared ambient pressure. Empirical ambient correlation, not a general steam/ice or cryogenic property solver."])
+def water_pressure(x):
+    pressure=1013*(100*x.relative_humidity_fraction)*math.exp(14.4114-5328/x.ambient_temperature_k)
+    ensure(pressure <= x.ambient_pressure_pa_abs,"Water partial pressure exceeds ambient pressure; correlation/conditions outside physical domain")
+    return {"water_partial_pressure_pa":pressure}
+
+
+class Transmissivity(Model):
+    water_partial_pressure_pa: NonNegative
+    path_length_m: Positive
+
+
+@calculation("effects/atmospheric-transmissivity", "Water-vapor thermal-radiation transmissivity", Transmissivity,
+             ["Part3 eq(3.140), Annex3.B C19; PDF pp552,648"],
+             limitations=["Equation exponent-.09 and C19=1.085 with pressure in kPa. Annex dimensional exponent.092 differs; equation exponent followed. Capped at physical maximum1. At zero water pressure uses limiting tau=1 and reports no finite uncapped value."])
+def transmissivity(x):
+    if x.water_partial_pressure_pa == 0:
+        return {"transmissivity":1,"uncapped_transmissivity":None,"dry_air_limit":True}
+    # Log form avoids underflow in pressure*distance before negative exponent.
+    raw=1.085*math.exp(-.09*(math.log(x.water_partial_pressure_pa)-math.log(1000)+math.log(x.path_length_m)))
+    return {"transmissivity":min(1,raw),"uncapped_transmissivity":raw,"dry_air_limit":False}
+
+
+class MixtureComponent(Model):
+    mole_fraction: Fraction
+    burning_rate_kg_m2_s: NonNegative
+
+
+class MixtureBurning(Model):
+    components: list[MixtureComponent] = Field(min_length=1,max_length=100)
+
+
+@calculation("effects/pool-mixture-burning-rate", "Mole-weighted liquid-mixture pool burning rate", MixtureBurning,
+             ["Part3 eq(3.130); PDF p550"],
+             limitations=["Source mole-fraction weighting of supplied component burning rates; not a mixture thermodynamic or unignited evaporation model. Fractions must sum to1 and are not silently normalized."])
+def mixture_burning(x):
+    ensure(math.isclose(math.fsum(c.mole_fraction for c in x.components),1,rel_tol=0,abs_tol=1e-9),"Mole fractions must sum to1")
+    return {"burning_rate_kg_m2_s":math.fsum(c.mole_fraction*c.burning_rate_kg_m2_s for c in x.components)}
+
+
+class FlameGeometry(Model):
+    pool_radius_m: Positive
+    burning_rate_kg_m2_s: Positive
+    air_density_kg_m3: Positive
+    vapor_density_kg_m3: Positive
+    wind_speed_m_s: NonNegative
+    gravity_m_s2: Positive = 9.81
+
+
+@calculation("effects/pool-flame-geometry", "Thomas pool flame length and wind tilt", FlameGeometry,
+             ["Part3 eqs(3.135)-(3.137); PDF p551"],
+             limitations=["Air density enters Thomas length; vapor density enters nondimensional wind (not interchangeable). Wind must be qualified at source reference height6ft above grade. Printed powers.67,.333,-.21 followed. No automatic wind-height conversion or LH2 validation."])
+def flame_geometry(x):
+    wind=max(1,x.wind_speed_m_s*(x.vapor_density_kg_m3/(2*x.gravity_m_s2*x.burning_rate_kg_m2_s*x.pool_radius_m))**.333)
+    length=110*x.pool_radius_m*(x.burning_rate_kg_m2_s/(x.air_density_kg_m3*math.sqrt(2*x.gravity_m_s2*x.pool_radius_m)))**.67*wind**(-.21)
+    tilt=math.acos(1/math.sqrt(wind))
+    ensure(math.isfinite(wind) and math.isfinite(length) and length > 0 and tilt < math.pi/2,
+           "Flame geometry exceeds finite numerical domain", "numerical_failure")
+    return {"nondimensional_wind_speed":wind,"flame_length_m":length,"flame_tilt_rad":tilt,
+            "vertical_flame_height_m":length*math.cos(tilt),"downwind_axis_extension_m":length*math.sin(tilt)}
+
+
+class SurfaceEmissive(Model):
+    pool_radius_m: Positive
+    flame_length_m: Positive
+    burning_rate_kg_m2_s: Positive
+    heat_of_combustion_j_kg: Positive
+    radiative_fraction: Fraction = .35
+
+
+@calculation("effects/pool-surface-emissive-power", "Pool flame surface emissive power", SurfaceEmissive,
+             ["Part3 eq(3.138); PDF p551"],
+             limitations=["Surface emissive power W/m2, not total radiated power W. Uses printed cylindrical side-plus-top area2*pi*R*L+pi*R^2. Uniform emissive surface; no smoke shielding or fuel-specific emissivity model."])
+def surface_emissive(x):
+    burning_mass=x.burning_rate_kg_m2_s*math.pi*x.pool_radius_m**2
+    power=x.radiative_fraction*burning_mass*x.heat_of_combustion_j_kg
+    area=2*math.pi*x.pool_radius_m*x.flame_length_m+math.pi*x.pool_radius_m**2
+    ensure(math.isfinite(power) and math.isfinite(area) and area > 0,
+           "Pool radiated power/surface area exceeds numerical domain", "numerical_failure")
+    return {"burning_mass_rate_kg_s":burning_mass,"radiated_power_w":power,
+            "emitting_surface_area_m2":area,"surface_emissive_power_w_m2":power/area}
+
+
+class CylinderView(Model):
+    length_radius_ratio: Positive
+    distance_radius_ratio: Positive
+    flame_tilt_rad: Tilt
+    equation_basis: EquationBasis
+
+
+@calculation("effects/pool-cylinder-view-factor", "Pool cylinder vertical/horizontal/maximum view factors", CylinderView,
+             ["Part3 eqs(3.142)-(3.149); PDF pp552-553", "Independent oblique-cylinder surface integral: docs/POOL_RADIATION_VALIDATION.md"],
+             origin="explicit_printed_or_geometrically_checked_equations",
+             limitations=["Printed2016 Fv has atan(q), not atan(sqrt(q)), and numerator2Y(1+sin(theta)), not2Y(1+Xsin(theta)). api581_printed reproduces these; geometry_checked makes the two explicit changes verified against independent side-surface integration. Not an authorized standard erratum. Requires Y>1+Xsin(theta), outside downwind flame projection. Ground target in tilt plane; uniform side emission. Physical-range flag must be checked before flux use."])
+def cylinder_view(x):
+    X,Y=x.length_radius_ratio,x.distance_radius_ratio
+    s,c=math.sin(x.flame_tilt_rad),math.cos(x.flame_tilt_rad)
+    ensure(Y > 1+X*s,"Target must be outside downwind flame projection: Y > 1+X*sin(tilt)")
+    A=(X*c)**2+(Y+1-X*s)**2
+    B=(X*c)**2+(Y-1-X*s)**2
+    D=Y*Y-1
+    C=1+D*c*c
+    q=A*(Y-1)/(B*(Y+1))
+    common=math.atan2(X*Y/(math.sqrt(D)*math.sqrt(C)),1-s*(X*Y-D*s)/C)
+    numerator=((X*c)**2+(Y-X*s)**2+1 if x.equation_basis == "geometry_checked"
+               else X*X+(Y+1)**2-2*Y*(1+s))
+    vertical_atan=math.atan(math.sqrt(q) if x.equation_basis == "geometry_checked" else q)
+    fv=(X*c/(Y-X*s)*numerator/(math.pi*math.sqrt(A*B))*vertical_atan
+        +c/(math.pi*math.sqrt(C))*common
+        -X*c/(math.pi*(Y-X*s))*math.atan(math.sqrt((Y-1)/(Y+1))))
+    fh=(math.atan(math.sqrt((Y+1)/(Y-1)))/math.pi
+        -(X*X+(Y+1)**2-2*(Y+1+X*Y*s))/(math.pi*math.sqrt(A*B))*math.atan(math.sqrt(q))
+        +s/(math.pi*math.sqrt(C))*common)
+    combined=math.hypot(fv,fh)
+    physical=min(fv,fh) >= -1e-12 and max(fv,fh,combined) <= 1+1e-12
+    return {"vertical_view_factor":fv,"horizontal_view_factor":fh,"maximum_view_factor":combined,
+            "physical_range":physical,"equation_basis":x.equation_basis}
+
+
+class Atmosphere(Model):
+    transmissivity_model: Literal["constant","api_water_vapor"]
+    constant_transmissivity: Fraction | None = None
+    water_partial_pressure_pa: NonNegative | None = None
+
+
+def _atmosphere(x,distance):
+    ensure((x.transmissivity_model == "constant" and x.constant_transmissivity is not None and x.water_partial_pressure_pa is None)
+           or (x.transmissivity_model == "api_water_vapor" and x.water_partial_pressure_pa is not None and x.constant_transmissivity is None),
+           "Provide exactly the parameter for selected transmissivity model")
+    return x.constant_transmissivity if x.transmissivity_model == "constant" else transmissivity(
+        Transmissivity(water_partial_pressure_pa=x.water_partial_pressure_pa,path_length_m=distance))["transmissivity"]
+
+
+class RadiationSetup(Model):
+    pool_radius_m: Positive
+    flame_length_m: Positive
+    flame_tilt_rad: Tilt
+    surface_emissive_power_w_m2: NonNegative
+    atmosphere: Atmosphere
+    equation_basis: EquationBasis
+    distance_convention: DistanceConvention
+
+
+class PoolFlux(RadiationSetup):
+    surface_distance_m: Positive
+
+
+@calculation("effects/pool-radiation-flux", "Pool thermal radiation at a specified surface separation", PoolFlux,
+             ["Part3 eqs(3.139)-(3.149); PDF pp552-553"],
+             origin="api581_surface_flux_with_explicit_geometry_basis",
+             limitations=["Source nomenclature defines xs from flame surface, but printed Y=xs/R conflicts with axis-distance geometry. Caller selects printed_surface_ratio (Y=xs/R) or surface_to_axis (Y=(xs+R)/R). Atmospheric path always uses surface separation. Invalid physical view factors are rejected; no automatic formula fallback."])
+def pool_flux(x):
+    distance=x.surface_distance_m+(x.pool_radius_m if x.distance_convention == "surface_to_axis" else 0)
+    view=cylinder_view(CylinderView(length_radius_ratio=x.flame_length_m/x.pool_radius_m,
+        distance_radius_ratio=distance/x.pool_radius_m,flame_tilt_rad=x.flame_tilt_rad,equation_basis=x.equation_basis))
+    ensure(view["physical_range"],"Selected printed/geometric view factor lies outside physical range", "invalid_view_factor")
+    tau=_atmosphere(x.atmosphere,x.surface_distance_m)
+    return {"received_flux_w_m2":tau*x.surface_emissive_power_w_m2*view["maximum_view_factor"],
+            "transmissivity":tau,"maximum_view_factor":view["maximum_view_factor"],"view_factor_distance_m":distance,
+            "equation_basis":x.equation_basis,"distance_convention":x.distance_convention}
+
+
+class PoolDistance(RadiationSetup):
+    threshold_w_m2: Positive
+    maximum_surface_distance_m: Positive
+    distance_tolerance_m: Positive = 1e-5
+    maximum_iterations: int = Field(default=100,ge=10,le=300,strict=True)
+
+
+@calculation("effects/pool-fire-distance", "Pool radiation threshold separation and consequence area", PoolDistance,
+             ["Part3 §5.8.2.6; eqs(3.150)-(3.151); PDF p553"],
+             origin="api581_threshold_iteration_with_explicit_geometry_basis",
+             limitations=["Assumes decreasing flux outside downwind flame envelope. Solves only within supplied maximum distance; no implicit expansion or far-field substitution. If flux already below limit at domain boundary, returns conservative flame-envelope separation and boundary status, not a claimed threshold crossing. Area always pi*(surface_distance+pool_radius)^2. Printed formula/geometry and distance convention are explicit; no validated LH2 applicability."])
+def pool_distance(x):
+    envelope=x.flame_length_m*math.sin(x.flame_tilt_rad)
+    minimum=envelope+(x.pool_radius_m if x.distance_convention == "printed_surface_ratio" else 0)
+    lo=minimum+max(1e-9,1e-8*x.pool_radius_m)
+    hi=x.maximum_surface_distance_m
+    ensure(hi > lo,"Maximum surface distance must lie outside flame/view-factor domain")
+    def flux(distance):
+        return pool_flux(PoolFlux(**{k:getattr(x,k) for k in RadiationSetup.model_fields},surface_distance_m=distance))["received_flux_w_m2"]
+    lower,upper=flux(lo),flux(hi)
+    ensure(upper <= x.threshold_w_m2,"Threshold not bracketed; increase maximum surface distance", "unbracketed_threshold")
+    if lower <= x.threshold_w_m2:
+        distance,status,iterations,residual=minimum,"below_limit_at_domain_boundary",0,None
+    else:
+        iterations=0
+        while hi-lo > x.distance_tolerance_m and iterations < x.maximum_iterations:
+            mid=lo+(hi-lo)/2
+            if flux(mid) > x.threshold_w_m2:lo=mid
+            else:hi=mid
+            iterations+=1
+        ensure(hi-lo <= x.distance_tolerance_m,"Threshold solver did not converge", "nonconvergent_threshold")
+        distance,status=hi,"threshold_solved"
+        residual=flux(distance)-x.threshold_w_m2
+    return {"safe_surface_distance_m":distance,"consequence_radius_m":distance+x.pool_radius_m,
+            "consequence_area_m2":math.pi*(distance+x.pool_radius_m)**2,"status":status,
+            "iterations":iterations,"flux_residual_w_m2":residual,"minimum_surface_domain_m":minimum,
+            "equation_basis":x.equation_basis,"distance_convention":x.distance_convention}
+
+
+class PoolConsequence(Model):
+    burning: PoolBurning
+    liquid_rate_kg_s: NonNegative
+    available_liquid_mass_kg: NonNegative
+    liquid_density_kg_m3: Positive
+    pool_depth_m: Positive = .005
+    site_maximum_area_m2: Positive
+    air_density_kg_m3: Positive
+    vapor_density_kg_m3: Positive
+    wind_speed_m_s: NonNegative
+    radiative_fraction: Fraction = .35
+    atmosphere: Atmosphere
+    equation_basis: EquationBasis
+    distance_convention: DistanceConvention
+    maximum_surface_distance_m: Positive
+    personnel_threshold_w_m2: Positive = 12600
+    equipment_threshold_w_m2: Positive = 37800
+
+
+@calculation("effects/pool-fire-consequence", "Compose burning, pool size, flame and radiation consequence areas", PoolConsequence,
+             ["Part3 §5.8.2; eqs(3.128)-(3.151); PDF pp550-553"],
+             origin="api581_pool_chain_with_explicit_geometry_basis",
+             limitations=["Single pool/event only; no ignition/event or hole weighting. Qualified liquid rainout rate/mass supplied; inventory input is liquid mass, not automatic substitution of ambiguous frac_ro in printed eq(3.132). Site limit mandatory. Explicit printed/geometry_checked and distance choices; source-view-factor discrepancies are not silently corrected. Uniform plume model, no smoke/terrain/flame-impingement or LH2-specific validation."])
+def pool_consequence(x):
+    rate=pool_burning(x.burning)["burning_rate_kg_m2_s"]
+    ensure(math.isfinite(rate) and rate > 0,"Pool burning rate underflow/overflow", "numerical_failure")
+    area=pool_area(PoolArea(liquid_rate_kg_s=x.liquid_rate_kg_s,burning_rate_kg_m2_s=rate,
+        available_liquid_mass_kg=x.available_liquid_mass_kg,density_kg_m3=x.liquid_density_kg_m3,
+        pool_depth_m=x.pool_depth_m,site_maximum_area_m2=x.site_maximum_area_m2))
+    # Validate atmosphere contract even for an empty pool.
+    _atmosphere(x.atmosphere,1)
+    if area["pool_radius_m"] == 0:
+        return {"burning_rate_kg_m2_s":rate,**area,"flame_length_m":0,"flame_tilt_rad":0,
+                "surface_emissive_power_w_m2":0,"personnel_area_m2":0,"equipment_area_m2":0,
+                "personnel_safe_surface_distance_m":0,"equipment_safe_surface_distance_m":0,
+                "personnel_status":"no_pool","equipment_status":"no_pool",
+                "equation_basis":x.equation_basis,"distance_convention":x.distance_convention}
+    flame=flame_geometry(FlameGeometry(pool_radius_m=area["pool_radius_m"],burning_rate_kg_m2_s=rate,
+        air_density_kg_m3=x.air_density_kg_m3,vapor_density_kg_m3=x.vapor_density_kg_m3,wind_speed_m_s=x.wind_speed_m_s))
+    emitted=surface_emissive(SurfaceEmissive(pool_radius_m=area["pool_radius_m"],flame_length_m=flame["flame_length_m"],
+        burning_rate_kg_m2_s=rate,heat_of_combustion_j_kg=x.burning.heat_of_combustion_j_kg,radiative_fraction=x.radiative_fraction))
+    setup=dict(pool_radius_m=area["pool_radius_m"],flame_length_m=flame["flame_length_m"],flame_tilt_rad=flame["flame_tilt_rad"],
+        surface_emissive_power_w_m2=emitted["surface_emissive_power_w_m2"],atmosphere=x.atmosphere,
+        equation_basis=x.equation_basis,distance_convention=x.distance_convention,maximum_surface_distance_m=x.maximum_surface_distance_m)
+    personnel=pool_distance(PoolDistance(**setup,threshold_w_m2=x.personnel_threshold_w_m2))
+    equipment=pool_distance(PoolDistance(**setup,threshold_w_m2=x.equipment_threshold_w_m2))
+    return {"burning_rate_kg_m2_s":rate,**area,"flame_length_m":flame["flame_length_m"],"flame_tilt_rad":flame["flame_tilt_rad"],
+            "surface_emissive_power_w_m2":emitted["surface_emissive_power_w_m2"],
+            "personnel_area_m2":personnel["consequence_area_m2"],"equipment_area_m2":equipment["consequence_area_m2"],
+            "personnel_safe_surface_distance_m":personnel["safe_surface_distance_m"],"equipment_safe_surface_distance_m":equipment["safe_surface_distance_m"],
+            "personnel_status":personnel["status"],"equipment_status":equipment["status"],
+            "equation_basis":x.equation_basis,"distance_convention":x.distance_convention}

api581/portfolio.py

@@ -0,0 +1,68 @@
+"""Portfolio-level risk aggregation for digital-twin and site assessments.
+
+This is an integration calculation: each component risk is supplied by a
+qualified component assessment and is not recomputed here.  Component
+scenarios must be disjoint (or the caller must partition them before calling).
+"""
+import math
+
+from pydantic import Field
+
+from .core import Model, NonNegative, calculation, ensure
+
+
+class PortfolioComponent(Model):
+    component_id: str = Field(min_length=1, max_length=200)
+    annual_failure_frequency: NonNegative
+    equipment_area_risk_m2_per_year: NonNegative
+    personnel_area_risk_m2_per_year: NonNegative
+    financial_risk_per_year: NonNegative
+
+
+class PortfolioRisk(Model):
+    components: list[PortfolioComponent] = Field(min_length=1, max_length=100000)
+    currency: str = Field(pattern=r"^[A-Z]{3}$")
+    disjointness_basis: str = Field(min_length=1, max_length=1000)
+
+
+@calculation(
+    "risk/portfolio",
+    "Aggregate qualified component risks for a site or digital-twin portfolio",
+    PortfolioRisk,
+    ["Part 1 §4.3.1; Part 1 §4.3.2"],
+    origin="engineering_utility",
+    limitations=[
+        "Each component row must already be a mutually exclusive annual risk contribution on the same currency and consequence basis.",
+        "This API does not deduplicate shared release scenarios, normalize currencies, or infer individual/societal risk.",
+        "The disjointness_basis is an auditable owner declaration, not an automatic proof of independence.",
+    ],
+)
+def portfolio(x: PortfolioRisk):
+    ensure(
+        len({row.component_id for row in x.components}) == len(x.components),
+        "Duplicate component_id",
+    )
+    frequency = math.fsum(row.annual_failure_frequency for row in x.components)
+    equipment = math.fsum(row.equipment_area_risk_m2_per_year for row in x.components)
+    personnel = math.fsum(row.personnel_area_risk_m2_per_year for row in x.components)
+    financial = math.fsum(row.financial_risk_per_year for row in x.components)
+    contributions = {
+        row.component_id: {
+            "annual_failure_frequency": row.annual_failure_frequency,
+            "equipment_area_risk_m2_per_year": row.equipment_area_risk_m2_per_year,
+            "personnel_area_risk_m2_per_year": row.personnel_area_risk_m2_per_year,
+            "financial_risk_per_year": row.financial_risk_per_year,
+        }
+        for row in x.components
+    }
+    return {
+        "component_count": len(x.components),
+        "annual_failure_frequency": frequency,
+        "equipment_area_risk_m2_per_year": equipment,
+        "personnel_area_risk_m2_per_year": personnel,
+        "area_risk_m2_per_year": max(equipment, personnel),
+        "financial_risk_per_year": financial,
+        "currency": x.currency,
+        "disjointness_basis": x.disjointness_basis,
+        "component_contributions": contributions,
+    }

api581/prd.py

@@ -0,0 +1,204 @@
+"""Part 1 §7 pressure-relief-device reliability primitives."""
+import math
+from typing import Literal
+from pydantic import Field, StrictBool
+from .core import Model, NonNegative, Positive, Fraction, calculation, ensure
+from .pof import Weibull, weibull, HOLES
+
+Device = Literal["conventional", "balanced_bellows", "pilot_operated", "rupture_disk"]
+Mode = Literal["fail_to_open", "leak"]
+Severity = Literal["mild", "moderate", "severe"]
+
+
+class PrdDefaults(Model):
+    device_type: Device
+    failure_mode: Mode
+    severity: Severity
+    closed_system_or_flare: StrictBool = False
+    soft_seated: StrictBool = False
+
+
+@calculation("prd/default-weibull", "PRD default Weibull parameters and design modifiers", PrdDefaults,
+             ["Part 1 Tables 7.5,7.12; §7.2.4(g),§7.3.2(g); PDF pp53,62,83,87"],
+             limitations=["Owner selects severity independently for FAIL and LEAK. Uses printed rounded pilot-operated eta (33.7,8.0,3.5), not another division of these entries. Closed-system factor .75 applies only to conventional FAIL; soft-seat factor 1.25 only to conventional/balanced LEAK. Environmental and inspection adjustments are separate."])
+def prd_defaults(x):
+    i = ("mild","moderate","severe").index(x.severity)
+    if x.failure_mode == "fail_to_open":
+        shape = 1.8
+        eta = 50.5 if x.device_type == "rupture_disk" else ((33.7,8,3.5) if x.device_type == "pilot_operated" else (50.5,23.9,17.6))[i]
+        factor = .75 if x.device_type == "conventional" and x.closed_system_or_flare else 1
+    else:
+        shape = 1.6
+        eta = 17.5 if x.device_type == "rupture_disk" else ((16,14,11.5) if x.device_type == "balanced_bellows" else (17.5,15.5,13.1))[i]
+        factor = 1.25 if x.soft_seated and x.device_type in ("conventional","balanced_bellows") else 1
+    return {"shape":shape,"default_characteristic_life_years":eta,"design_factor":factor,
+            "design_adjusted_characteristic_life_years":eta*factor}
+
+
+class PrdEnvironment(Model):
+    device_type: Device
+    failure_mode: Mode
+    operating_temperature_k: Positive
+    operating_to_set_pressure_ratio: NonNegative
+    installed_piping_vibration: StrictBool
+    pulsating_or_cyclic_service: StrictBool
+    actuations_per_year: NonNegative
+    history_of_chatter: StrictBool
+    qualified_pilot_high_ratio_exception: StrictBool = False
+
+
+@calculation("prd/environment-factor", "PRD environmental characteristic-life modifier", PrdEnvironment,
+             ["Part 1 Table 7.6; PDF p83"],
+             limitations=["Products of applicable modifiers. LEAK excessive-actuation modifier is not reapplied when operating-ratio modifier applies (Table7.6 note2). Pilot high-ratio exception must be explicitly qualified. Printed strict 200<T<500 F and T>500 F leave exactly 500 F unresolved for LEAK; it is rejected. FAIL does not use temperature/ratio/vibration/cyclic factors."])
+def prd_environment(x):
+    ensure(not x.qualified_pilot_high_ratio_exception or x.device_type == "pilot_operated", "High operating-ratio exception applies only to qualified pilot-operated devices")
+    factors = {"chatter":.5 if x.history_of_chatter else 1,
+               "excessive_actuation":.5 if x.actuations_per_year > 5 else 1}
+    if x.failure_mode == "leak":
+        t200 = (200-32)*5/9+273.15
+        t500 = (500-32)*5/9+273.15
+        ensure(not math.isclose(x.operating_temperature_k,t500,rel_tol=0,abs_tol=1e-9),
+               "Exactly 500 F is not assigned by printed Table7.6 temperature bands", "unresolved_applicability")
+        threshold = .95 if x.device_type == "pilot_operated" else .9
+        ratio_applies = x.device_type != "rupture_disk" and x.operating_to_set_pressure_ratio > threshold and not x.qualified_pilot_high_ratio_exception
+        factors.update(temperature=.6 if x.operating_temperature_k > t500 else (.8 if x.operating_temperature_k > t200 else 1),
+                       operating_ratio=.5 if ratio_applies else 1,
+                       vibration=.8 if x.installed_piping_vibration else 1,
+                       cyclic_service=.8 if x.pulsating_or_cyclic_service else 1)
+        if ratio_applies:
+            factors["excessive_actuation"] = 1
+    return {"environment_factor":math.prod(factors.values()),"individual_factors":factors}
+
+
+class PrdSetPressure(Model):
+    device_type: Device
+    operating_to_set_pressure_ratio: NonNegative
+
+
+@calculation("prd/set-pressure-factor", "PRD leakage set-pressure probability modifier", PrdSetPressure,
+             ["Part 1 Table 7.7; eq (1.36); PDF pp61,84"],
+             limitations=["Pressure ratio supplied on a consistent pressure basis. Applies to leakage probability after Weibull evaluation, not to eta. Rupture-disk factor=1."])
+def prd_set_pressure(x):
+    limit = .95 if x.device_type == "pilot_operated" else .9
+    return {"set_pressure_factor":1 if x.device_type == "rupture_disk" else min(limit,x.operating_to_set_pressure_ratio)/limit}
+
+
+class PrdOverpressure(Model):
+    overpressure_to_set_pressure_ratio: Positive
+
+
+@calculation("prd/overpressure-factor", "PRD fail-to-open overpressure modifier", PrdOverpressure,
+             ["Part 1 §7.2.4(j); eq (1.31); PDF pp57-58"])
+def prd_overpressure(x):
+    return {"overpressure_factor":max(.2,min(1,1-(x.overpressure_to_set_pressure_ratio-1.3)/3.375))}
+
+
+class DemandCase(Model):
+    initiating_event_frequency_per_year: NonNegative
+    demand_rate_reduction_factor: Fraction
+
+
+class PrdDemand(Model):
+    cases: list[DemandCase] = Field(min_length=1, max_length=100)
+
+
+@calculation("prd/demand-rate", "PRD case and total demand rates", PrdDemand,
+             ["Part 1 §7.2.3; eqs (1.12)-(1.13); PDF p50"],
+             limitations=["Reduction factor is the residual fraction multiplying initiating frequency, not its reciprocal. Owner qualifies independent demand cases and LOPA credits; defaults/automatic relief-design basis are not inferred."])
+def prd_demand(x):
+    values = [c.initiating_event_frequency_per_year*c.demand_rate_reduction_factor for c in x.cases]
+    return {"case_demand_rates_per_year":values,"total_demand_rate_per_year":math.fsum(values)}
+
+
+class InspectionUpdate(Model):
+    shape: Positive
+    prior_characteristic_life_years: Positive
+    duration_years: NonNegative
+    effectiveness: Literal["ineffective", "fairly", "usually", "highly"]
+    result: Literal["pass", "fail", "no_leak", "leak"]
+    piping_plugged: StrictBool = False
+
+
+@calculation("prd/inspection-update", "PRD single inspection characteristic-life update", InspectionUpdate,
+             ["Part 1 §7.2.4(i); eqs (1.17)-(1.21); Tables7.8,7.9; PDF pp54-57,84"],
+             limitations=["Implements printed eq (1.20), including CF_pass in its second term. Ineffective tests and durations<1 year get no update. Pass/no-leak cannot reduce eta, fail/leak cannot increase eta. Plugged piping overrides pass to fail. Caller sequences records and handles overhaul/as-new date and invalidation after design change. Invalid weighted probability is rejected, not clipped."])
+def prd_inspection_update(x):
+    prior = weibull(Weibull(shape=x.shape,characteristic_life_years=x.prior_characteristic_life_years,
+        age_years=x.duration_years))["cumulative_failure_probability"]
+    failed = x.piping_plugged or x.result in ("fail","leak")
+    if x.effectiveness == "ineffective" or x.duration_years < 1:
+        return {"prior_failure_probability":prior,"conditional_failure_probability":None,
+                "weighted_failure_probability":prior,"updated_characteristic_life_years":x.prior_characteristic_life_years,
+                "update_applied":False,"effective_failed_result":failed}
+    pass_cf,fail_cf = {"fairly":(.5,.7),"usually":(.7,.95),"highly":(.9,.95)}[x.effectiveness]
+    conditional = fail_cf*prior+(1-pass_cf)*(1-prior) if failed else (1-pass_cf)*(1-prior)
+    if failed:
+        weighted = .5*(prior+conditional) if x.effectiveness == "fairly" else conditional
+    else:
+        weighted = prior+.2*(x.duration_years/x.prior_characteristic_life_years)*(conditional-prior)
+    ensure(0 < weighted < 1, "Inspection update gives probability outside open interval (0,1)", "outside_update_domain")
+    eta = x.duration_years/(-math.log1p(-weighted))**(1/x.shape)
+    eta = min(eta,x.prior_characteristic_life_years) if failed else max(eta,x.prior_characteristic_life_years)
+    return {"prior_failure_probability":prior,"conditional_failure_probability":conditional,
+            "weighted_failure_probability":weighted,"updated_characteristic_life_years":eta,
+            "update_applied":True,"effective_failed_result":failed}
+
+
+class ProtectedEquipment(Model):
+    generic_frequencies_per_year: dict[Literal["small","medium","large","rupture"], NonNegative]
+    total_damage_factor: NonNegative
+    management_factor: Positive
+    overpressure_to_mawp_ratio: Positive
+
+
+@calculation("prd/protected-equipment", "Protected equipment overpressure loss-of-containment model", ProtectedEquipment,
+             ["Part 1 §7.2.5; eqs (1.32)-(1.33); PDF p58"],
+             limitations=["Uses normal damage-adjusted frequency at pressure<=MAWP; above MAWP applies printed exponential and caps source-model probability at1. Source mixes annual-frequency/probability terms; returned source_model_loc_probability follows the published model, not a Poisson conversion. Caller supplies DF at evaluation time and all four GFF holes."])
+def protected_equipment(x):
+    ensure(set(x.generic_frequencies_per_year)==set(HOLES), "All four generic-frequency hole rows are required")
+    total = math.fsum(x.generic_frequencies_per_year.values())
+    ensure(total > 0, "Generic frequency total must be positive")
+    baseline = total*x.total_damage_factor*x.management_factor
+    if x.overpressure_to_mawp_ratio <= 1 or baseline == 0:
+        probability = min(1,baseline)
+    else:
+        logp = math.log(baseline)+math.log(.0312881)+3.464837*x.overpressure_to_mawp_ratio
+        probability = 1 if logp >= 0 else math.exp(logp)
+    return {"normal_failure_frequency_per_year":baseline,"source_model_loc_probability":probability,
+            "by_hole_loc_probability":{k:probability*v/total for k,v in x.generic_frequencies_per_year.items()}}
+
+
+class PrdFailFrequency(Model):
+    failure_on_demand_probability: Fraction
+    demand_rate_per_year: NonNegative
+    protected_equipment_loc_probability: Fraction
+
+
+@calculation("prd/fail-frequency", "PRD fail-to-open loss-of-containment scenario frequency", PrdFailFrequency,
+             ["Part 1 §7.2.2; eq (1.11); PDF p49"],
+             limitations=["One demand case: multiplies scenario-adjusted POFOD, demand rate and protected-equipment LOC model probability. Sum only justified distinct scenarios; dependencies and common-cause effects require owner analysis."])
+def prd_fail_frequency(x):
+    return {"annual_failure_frequency":x.failure_on_demand_probability*x.demand_rate_per_year*x.protected_equipment_loc_probability}
+
+
+class BaseReliability(Model):
+    defaults: PrdDefaults
+    environment: PrdEnvironment
+    age_years: NonNegative
+    overpressure_to_set_pressure_ratio: Positive = 1.3
+
+
+@calculation("prd/base-reliability", "PRD default/design/environment/scenario probability", BaseReliability,
+             ["Part 1 eqs (1.14)-(1.16),(1.34)-(1.36); Tables7.5-7.7,7.12"],
+             limitations=["Uninspected/default reliability path only; no implicit inspection history. Computes cumulative Weibull probability at age and applies Fop for FAIL or Fset for LEAK. LEAK result is not automatically reinterpreted as an instantaneous annual frequency. Caller supplies qualified severity, environmental and pressure inputs."])
+def prd_base_reliability(x):
+    ensure(x.defaults.device_type == x.environment.device_type and x.defaults.failure_mode == x.environment.failure_mode,
+           "Default and environment device/failure mode must match")
+    base,env = prd_defaults(x.defaults),prd_environment(x.environment)
+    eta = base["design_adjusted_characteristic_life_years"]*env["environment_factor"]
+    probability = weibull(Weibull(shape=base["shape"],characteristic_life_years=eta,age_years=x.age_years))["cumulative_failure_probability"]
+    factor = (prd_overpressure(PrdOverpressure(overpressure_to_set_pressure_ratio=x.overpressure_to_set_pressure_ratio))["overpressure_factor"]
+              if x.defaults.failure_mode == "fail_to_open" else
+              prd_set_pressure(PrdSetPressure(device_type=x.defaults.device_type,operating_to_set_pressure_ratio=x.environment.operating_to_set_pressure_ratio))["set_pressure_factor"])
+    return {"shape":base["shape"],"modified_characteristic_life_years":eta,"environment_factor":env["environment_factor"],
+            "scenario_probability_factor":factor,"unadjusted_cumulative_probability":probability,"scenario_adjusted_probability":probability*factor}