api581-engine 0.1.4__py3-none-any.whl

api581/level1_type1.py

@@ -0,0 +1,91 @@
+"""Type1 SI flammable tables; no Type0 continuous/instantaneous or AIT blending."""
+from typing import Literal
+from .core import Model, NonNegative, Fraction, calculation, ensure
+from .level1 import Coefficients, coefficients, Energy, energy, ControlledRelease, controlled_release
+
+Type1Fluid = Literal["Aromatics","Styrene","CO","DEE","Methanol","PO","EEA","EE","EG","EO"]
+
+# (continuous AINL, continuous AIL, instantaneous AINL, instantaneous AIL),
+# first equipment then personnel. None is a blank; (0,b) is a real zero.
+TYPE1_COEFFICIENTS = {
+    "Aromatics":{
+        "gas":[(3.952,1.097),(80.11,1.055),(1.804,.667),(83.68,.713), (12.76,.963),(261.9,.937),(2.889,.686),(83.68,.713)],
+        "liquid":[(21.10,1),None,(14.36,1),(143.6,1), (66.01,.883),(56,.268),(.027,.935),(.273,.935)]},
+    "CO":{"gas":[(.040,1.752),None,(10.97,.667),None, (5.491,.991),None,(16.91,.692),None]},
+    "DEE":{
+        "gas":[(9.072,1.134),(67.42,1.033),(24.51,.667),None, (26.76,1.025),(241.5,.997),(31.71,.682),(128.3,.657)],
+        "liquid":[(164.2,1.106),(976,.649),(.981,.919),(1.090,.919), (236.7,1.219),(488.9,.864),(8.333,.814),(9.258,.814)]},
+    "Methanol":{
+        "gas":[(.005,.909),None,(4.425,.667),None, (0,1.008),None,(6.035,.688),None],
+        "liquid":[(340.4,.934),None,(.363,.900),None, (849.9,.902),None,(1.157,.871),None]},
+    "PO":{
+        "gas":[(3.277,1.114),None,(10.32,.667),None, (8.239,1.047),None,(13.33,.682),None],
+        "liquid":[(257,.960),None,(.629,.869),None, (352.8,.840),None,(2.732,.834),None]},
+    "EEA":{
+        "gas":[(0,1.035),None,(1.261,.667),None, (0,.946),None,(1.825,.687),None],
+        "liquid":[(23.96,1),None,(14.13,1),None, (79.66,.835),None,(.030,.924),None]},
+    "EE":{
+        "gas":[(2.595,1.005),None,(6.119,.667),None, (7.107,.969),None,(25.36,.660),None],
+        "liquid":[(35.45,1),None,(14.79,1),None, (8.142,.800),None,(.029,.927),None]},
+    "EG":{
+        "gas":[(1.548,.973),None,(1.027,.667),None, (5.042,.947),None,(1.435,.687),None],
+        "liquid":[(22.12,1),None,(14.13,1),None, (59.96,.869),None,(.027,.922),None]},
+    "EO":{"gas":[(6.712,1.069),None,(21.46,.667),None, (11,1.105),None,(34.70,.665),None]},
+}
+TYPE1_COEFFICIENTS["Styrene"] = {phase:list(rows) for phase,rows in TYPE1_COEFFICIENTS["Aromatics"].items()}
+
+
+class Type1Area(Coefficients):
+    fluid: Type1Fluid
+    adjusted_rate_kg_s: NonNegative
+    released_mass_kg: NonNegative
+    mitigation_fraction: Fraction
+
+
+@calculation("level1/type1-flammable-area", "Type1 single-effect flammable consequence area", Type1Area,
+             ["Part 3 §4.1.5(b),§4.8.4,§4.8.8; Tables4.8M,4.9M; PDF pp484,492,522,524"],
+             limitations=["Ten Type1 flammable fluids. Caller selects phase, release type and AINL/AIL branch; no Type0 IC or AIT blending. Instantaneous energy correction follows STEP8.2 and §4.8.4. Blank cells are rejected, printed zero retained. Equipment/personnel are callable separately when only one source cell exists."])
+def type1_area(x):
+    ensure(x.fluid in TYPE1_COEFFICIENTS,"Not a supported Type1 flammable reference fluid")
+    cell = coefficients(Coefficients(**{k:getattr(x,k) for k in ("fluid","release_phase","effect","release_type","autoignition")}))
+    correction = energy(Energy(released_mass_kg=x.released_mass_kg))["energy_efficiency_factor"] if x.release_type == "instantaneous" else 1
+    magnitude = x.adjusted_rate_kg_s if x.release_type == "continuous" else x.released_mass_kg
+    return {"area_m2":cell["a"]*magnitude**cell["b"]*(1-x.mitigation_fraction)/correction,
+            "coefficient_a":cell["a"],"coefficient_b":cell["b"],"energy_efficiency_factor":correction}
+
+
+class Type1Consequence(Model):
+    fluid: Type1Fluid
+    release_phase: Literal["gas","liquid"]
+    release_type: Literal["continuous","instantaneous"]
+    autoignition: Literal["not_likely","likely"]
+    adjusted_rate_kg_s: NonNegative
+    released_mass_kg: NonNegative
+    mitigation_fraction: Fraction
+
+
+@calculation("level1/type1-flammable-consequence", "Type1 equipment and personnel flammable areas", Type1Consequence,
+             ["Part 3 §4.1.5(b),§4.8.8; Tables4.8M,4.9M"],
+             limitations=["Unblended Type1 branch selected explicitly by caller. Requires populated equipment and personnel cells; use type1-flammable-area to query just one effect. Energy/mitigation applied once; coefficients already incorporate event probabilities."])
+def type1_consequence(x):
+    values = {effect:type1_area(Type1Area(effect=effect,**x.model_dump())) for effect in ("equipment","personnel")}
+    return {"equipment_area_m2":values["equipment"]["area_m2"],"personnel_area_m2":values["personnel"]["area_m2"],
+            "energy_efficiency_factor":values["equipment"]["energy_efficiency_factor"],"fluid_type":1}
+
+
+class ReleaseToType1(ControlledRelease):
+    fluid: Type1Fluid
+    final_release_phase: Literal["gas","liquid"]
+    autoignition: Literal["not_likely","likely"]
+    mitigation_fraction: Fraction
+
+
+@calculation("level1/release-to-type1-flammable", "Compose controlled release and Type1 flammable consequence", ReleaseToType1,
+             ["Part 3 §§4.3-4.8; §4.1.5(b)"],
+             limitations=["Single qualified hole. Uses gas/liquid source, inventory and detection/isolation duration; Type1 phase/AIT branch is caller-qualified. No Type0 blending. Toxic/financial/other-hole aggregation remain separate composable functions."])
+def release_to_type1(x):
+    released = controlled_release(x)
+    consequence = type1_consequence(Type1Consequence(fluid=x.fluid,release_phase=x.final_release_phase,
+        release_type=released["release_type"],autoignition=x.autoignition,adjusted_rate_kg_s=released["adjusted_rate_kg_s"],
+        released_mass_kg=released["released_mass_kg"],mitigation_fraction=x.mitigation_fraction))
+    return {**released,**consequence}

api581/level2_summary.py

@@ -0,0 +1,237 @@
+"""Level2 event weighting, non-ignition maxima, GFF averages and assessment.
+
+Unlike Level1, eqs3.202/203 ADD flammable areas to the non-ignition branch.
+"""
+import math
+from typing import Literal
+from pydantic import Field
+from .core import Model, NonNegative, Fraction, calculation, ensure
+from .physical_explosion import NfntCase, nfnt_case
+from .toxic_level2 import ToxicCloudArea, ToxicCase, toxic_case
+from .pof import Component, generic, Management, management, Frequency, adjusted
+from .cost_tables import RepairCost, ComponentOutage, FinancialConsequence, financial_consequence
+from .risk import Risk, RiskScenario, aggregate
+
+Hole=Literal["small","medium","large","rupture"]
+Event=Literal["pool_fire","jet_fire","fireball","vce","flash_fire"]
+_EVENTS={"pool_fire","jet_fire","fireball","vce","flash_fire"}
+_MECHANISMS=("flammable_equipment_area_m2","flammable_personnel_area_m2","toxic_personnel_area_m2",
+             "nfnt_equipment_area_m2","nfnt_personnel_area_m2")
+
+
+class FlammableOutcome(Model):
+    event: Event
+    probability: Fraction
+    equipment_area_m2: NonNegative
+    personnel_area_m2: NonNegative
+
+
+class CorrelatedJetPool(Model):
+    probability: Fraction
+    jet_equipment_area_m2: NonNegative
+    jet_personnel_area_m2: NonNegative
+    pool_equipment_area_m2: NonNegative
+    pool_personnel_area_m2: NonNegative
+    consequence_source: str = Field(min_length=1,max_length=1000)
+
+
+@calculation("level2/correlated-jet-pool", "One immediate-ignition branch with max(jet,pool) area", CorrelatedJetPool,
+             ["Part3 Figure5.3 two-phase continuous immediate branch; PDF p586; eqs(3.176)-(3.177)"],
+             origin="api581_correlated_two_phase_immediate_area",
+             limitations=["One branch probability applies to maximum jet/pool area, separately for equipment and personnel. Do not treat jet and pool as two independent terminal probabilities or sum their areas. Source footprints supplied and qualified externally; no geometric union or simultaneous-fire radiation solver."])
+def correlated_jet_pool(x):
+    ensure(x.consequence_source.strip(),"Correlated branch consequence source must be nonblank")
+    equipment=max(x.jet_equipment_area_m2,x.pool_equipment_area_m2)
+    personnel=max(x.jet_personnel_area_m2,x.pool_personnel_area_m2)
+    def governing(jet,pool):
+        return "equal" if jet == pool else "jet" if jet > pool else "pool"
+    return {"equipment_area_m2":x.probability*equipment,"personnel_area_m2":x.probability*personnel,
+            "maximum_equipment_area_m2":equipment,"maximum_personnel_area_m2":personnel,
+            "governing_equipment":governing(x.jet_equipment_area_m2,x.pool_equipment_area_m2),
+            "governing_personnel":governing(x.jet_personnel_area_m2,x.pool_personnel_area_m2)}
+
+
+class FlammableCase(Model):
+    hole: Hole
+    release_type: Literal["continuous","instantaneous"]
+    outcomes: list[FlammableOutcome] = Field(min_length=5,max_length=5)
+    non_ignition_probability: Fraction
+    event_tree_source: str = Field(min_length=1,max_length=1000)
+    consequence_source: str = Field(min_length=1,max_length=1000)
+    fireball_applicability_basis: Literal["rupture_only_text","figure53_instantaneous"] = "rupture_only_text"
+    correlated_jet_pool: CorrelatedJetPool | None = None
+
+
+@calculation("level2/flammable-case", "Flammable areas with optional correlated immediate branch", FlammableCase,
+             ["Part3 eqs(3.176)-(3.177),Figure5.3; PDF pp559,586"],
+             limitations=["Requires pool,jet,fireball,VCE,flash outcomes exactly once, including explicit zero branches. Together with optional correlated_jet_pool and non-ignition probabilities they sum to1. Raw areas weighted once. Correlated max(jet,pool) only for continuous leakage; separate jet/pool branches must be zero. Fireball defaults to instantaneous rupture-only text; explicit figure53_instantaneous also permits figure5.3 instantaneous leakage. Caller qualifies tree/area sources."])
+def flammable_case(x):
+    ensure({o.event for o in x.outcomes} == _EVENTS,"Require five distinct canonical flammable outcomes")
+    ensure(x.event_tree_source.strip() and x.consequence_source.strip(),"Event-tree and consequence sources must be nonblank")
+    correlated={"equipment_area_m2":0,"personnel_area_m2":0}
+    if x.correlated_jet_pool is not None:
+        ensure(x.release_type == "continuous" and x.hole != "rupture","Correlated jet/pool branch only for continuous leakage")
+        ensure(all(o.probability == o.equipment_area_m2 == o.personnel_area_m2 == 0 for o in x.outcomes if o.event in {"jet_fire","pool_fire"}),
+               "Correlated branch cannot coexist with separate jet/pool probability or area")
+        correlated=correlated_jet_pool(x.correlated_jet_pool)
+    total=math.fsum([o.probability for o in x.outcomes]+[x.non_ignition_probability,
+        x.correlated_jet_pool.probability if x.correlated_jet_pool is not None else 0])
+    ensure(math.isclose(total,1,rel_tol=0,abs_tol=1e-10),"Flammable outcomes plus non-ignition probability must sum to1")
+    for outcome in x.outcomes:
+        inactive=(outcome.event == "fireball" and (x.release_type != "instantaneous" or (
+                  x.hole != "rupture" and x.fireball_applicability_basis != "figure53_instantaneous"))) or (
+                  outcome.event == "jet_fire" and x.release_type != "continuous")
+        ensure(not inactive or outcome.probability == outcome.equipment_area_m2 == outcome.personnel_area_m2 == 0,
+               "Inapplicable fireball/jet branch must have zero probability and area")
+    equipment=math.fsum([o.probability*o.equipment_area_m2 for o in x.outcomes]+[correlated["equipment_area_m2"]])
+    personnel=math.fsum([o.probability*o.personnel_area_m2 for o in x.outcomes]+[correlated["personnel_area_m2"]])
+    return {"flammable_equipment_area_m2":equipment,"flammable_personnel_area_m2":personnel,
+            "non_ignition_probability":x.non_ignition_probability,"terminal_probability_sum":total}
+
+
+class FinalArea(Model):
+    flammable_equipment_area_m2: NonNegative
+    flammable_personnel_area_m2: NonNegative
+    toxic_personnel_area_m2: NonNegative
+    nfnt_equipment_area_m2: NonNegative
+    nfnt_personnel_area_m2: NonNegative
+
+
+@calculation("level2/final-area", "Final Level2 component/personnel consequence areas", FinalArea,
+             ["Part3 eqs(3.202)-(3.204); PDF pp572-573"],
+             limitations=["Inputs must already be event- and hole-weighted on a common basis. Equipment=flammable+NFNT; personnel=flammable+max(toxic,NFNT); final=max(equipment,personnel). Safe-event areas are0. Do not replace with Level1 maximum over all mechanisms or apply non-ignition probability twice."])
+def final_area(x):
+    equipment=x.flammable_equipment_area_m2+x.nfnt_equipment_area_m2
+    nonignition=max(x.toxic_personnel_area_m2,x.nfnt_personnel_area_m2)
+    personnel=x.flammable_personnel_area_m2+nonignition
+    ensure(math.isfinite(equipment) and math.isfinite(personnel),"Final Level2 area exceeds numerical domain","numerical_failure")
+    return {"equipment_area_m2":equipment,"personnel_area_m2":personnel,"consequence_area_m2":max(equipment,personnel),
+            "non_ignition_personnel_area_m2":nonignition,
+            "governing_non_ignition_personnel_mechanism":"equal" if x.toxic_personnel_area_m2 == x.nfnt_personnel_area_m2 else (
+                "toxic" if x.toxic_personnel_area_m2 > x.nfnt_personnel_area_m2 else "nfnt")}
+
+
+class MechanismHole(FinalArea):
+    hole: Hole
+    generic_frequency_per_year: NonNegative
+
+
+class ConsequenceSummary(Model):
+    holes: list[MechanismHole] = Field(min_length=4,max_length=4)
+
+
+def _holes(cases):
+    ensure({c.hole for c in cases} == {"small","medium","large","rupture"},"Require four distinct canonical holes")
+
+
+@calculation("level2/consequence-summary", "GFF mechanism averages followed by Level2 final selection", ConsequenceSummary,
+             ["Part3 eqs(3.178)-(3.179),(3.191),(3.200)-(3.204); PDF pp560,567,570,572-573"],
+             origin="api581_level2_mechanism_composition",
+             limitations=["All four holes required. Input mechanism areas already include event/non-ignition probabilities. GFF averages are formed separately before final non-ignition maximum. Averaging per-hole maxima generally gives a different result. No DF-adjusted frequencies as GFF weights."])
+def consequence_summary(x):
+    _holes(x.holes)
+    total=math.fsum(h.generic_frequency_per_year for h in x.holes)
+    ensure(math.isfinite(total) and total > 0,"Total generic frequency must be finite and positive")
+    values={name:math.fsum(h.generic_frequency_per_year/total*getattr(h,name) for h in x.holes) for name in _MECHANISMS}
+    return {**values,**final_area(FinalArea(**values)),"generic_frequency_per_year":total}
+
+
+class NfntAreas(Model):
+    physical_equipment_area_m2: NonNegative = 0
+    physical_personnel_area_m2: NonNegative = 0
+    bleve_equipment_area_m2: NonNegative = 0
+    bleve_personnel_area_m2: NonNegative = 0
+    steam_chemical_personnel_area_m2: NonNegative = 0
+    consequence_source: str = Field(min_length=1,max_length=1000)
+
+
+class ScenarioCase(FlammableCase):
+    toxic_components: list[ToxicCloudArea] = Field(max_length=100)
+    toxic_applicability: Literal["evaluated","not_applicable"]
+    toxic_applicability_source: str = Field(min_length=1,max_length=1000)
+    nfnt: NfntAreas
+
+
+@calculation("level2/scenario-consequence", "One-hole flammable/toxic/NFNT mechanism consequences", ScenarioCase,
+             ["Part3 eqs(3.176)-(3.177),(3.188),(3.198)-(3.199),Figure5.3; PDF pp559,567,570,586"],
+             origin="api581_level2_conditional_scenario_composition",
+             limitations=["Supplied terminal probabilities and raw event/footprint areas; no release or dispersion calculation is inferred. One shared non-ignition probability drives toxic and NFNT. Empty toxic list requires explicit not_applicable with basis. Outputs remain separate mechanisms; final selection is after hole weighting."])
+def scenario_consequence(x):
+    ensure(x.toxic_applicability_source.strip() and x.nfnt.consequence_source.strip(),"Toxic applicability and NFNT sources must be nonblank")
+    ensure(bool(x.toxic_components) == (x.toxic_applicability == "evaluated"),"Toxic components must match explicit applicability")
+    flammable=flammable_case(FlammableCase(**x.model_dump(include=set(FlammableCase.model_fields))))
+    toxic=0
+    if x.toxic_components:
+        toxic=toxic_case(ToxicCase(components=x.toxic_components,non_ignition_probability=x.non_ignition_probability))["personnel_area_m2"]
+    nfnt=nfnt_case(NfntCase(**x.nfnt.model_dump(exclude={"consequence_source"}),hole=x.hole,
+        non_ignition_probability=x.non_ignition_probability))
+    return {**flammable,"toxic_personnel_area_m2":toxic,"nfnt_equipment_area_m2":nfnt["equipment_area_m2"],
+            "nfnt_personnel_area_m2":nfnt["personnel_area_m2"],"hole":x.hole}
+
+
+class FrequencyScenario(ScenarioCase):
+    generic_frequency_per_year: NonNegative
+
+
+class ScenarioSummary(Model):
+    cases: list[FrequencyScenario] = Field(min_length=4,max_length=4)
+
+
+@calculation("level2/scenario-summary", "Four raw event scenarios to final Level2 consequence areas", ScenarioSummary,
+             ["Part3 §§5.8.7-5.11 eqs(3.176)-(3.204); PDF pp559-573"],
+             origin="api581_level2_event_to_final_area_composition",
+             limitations=["Caller-qualified event probabilities and raw event/dispersion areas for all four holes. Composes conditional mechanisms, separate GFF averages, flammable addition and non-ignition maximum. Does not run thermodynamics, dispersion or applicability inference."])
+def scenario_summary(x):
+    _holes(x.cases)
+    holes=[]
+    for case in x.cases:
+        result=scenario_consequence(ScenarioCase(**case.model_dump(include=set(ScenarioCase.model_fields))))
+        holes.append(MechanismHole(hole=case.hole,generic_frequency_per_year=case.generic_frequency_per_year,
+            **{name:result[name] for name in _MECHANISMS}))
+    return consequence_summary(ConsequenceSummary(holes=holes))
+
+
+class FinancialBasis(Model):
+    repair: RepairCost
+    outage: ComponentOutage
+    equipment_cost_per_m2: NonNegative
+    production_cost_per_day: NonNegative
+    population_density_per_m2: NonNegative
+    cost_per_injury: NonNegative
+    weighted_cleanup_volume_m3: NonNegative
+    cleanup_cost_per_m3: NonNegative
+
+
+class Assessment(Model):
+    component_type: str = Field(min_length=1,max_length=100)
+    management_score: NonNegative = Field(le=1000)
+    total_damage_factor: NonNegative
+    damage_factor_source: str = Field(min_length=1,max_length=1000)
+    cases: list[ScenarioCase] = Field(min_length=4,max_length=4)
+    financial: FinancialBasis
+
+
+@calculation("level2/assessment", "Supplied Level2 event consequences to financial/annual risk", Assessment,
+             ["Part3 §§5.8.7-5.12 eqs(3.176)-(3.204); Part1 eqs(1.1),(1.6)-(1.8)"],
+             origin="api581_level2_supplied_event_area_and_damage_assessment",
+             limitations=["Explicit integration boundary: owner-qualified terminal probabilities, raw event/dispersion areas, applicability and total DF supplied. Computes GFF/Fms, Level2 area composition, five financial categories and component annual risk. Non-tank GFF only. Common component DF/Fms; no hole-specific DF substitution or automatic future damage model.",
+                          "Repair/outage component types must match assessment. Areas are computed here; cleanup volume/pricing/screening remain supplied. Financial equations reuse §4.12 per §5.12. Not a complete asset-data-to-risk workflow or independent certification."])
+def assessment(x):
+    ensure(x.damage_factor_source.strip(),"Damage factor source must be nonblank")
+    ensure(x.component_type == x.financial.repair.component_type == x.financial.outage.component_type,
+           "Assessment, repair and outage component types must match")
+    frequencies=generic(Component(component_type=x.component_type))
+    cases=[FrequencyScenario(**c.model_dump(),generic_frequency_per_year=frequencies["by_hole_per_year"][c.hole]) for c in x.cases]
+    area=scenario_summary(ScenarioSummary(cases=cases))
+    finance=financial_consequence(FinancialConsequence(**x.financial.model_dump(),
+        equipment_area_m2=area["equipment_area_m2"],personnel_area_m2=area["personnel_area_m2"]))
+    fms=management(Management(score=x.management_score))["management_factor"]
+    occurrence=adjusted(Frequency(generic_frequency_per_year=frequencies["total_per_year"],total_damage_factor=x.total_damage_factor,
+        management_factor=fms))["annual_failure_frequency"]
+    ensure(math.isfinite(occurrence) and (occurrence > 0 or x.total_damage_factor == 0),
+           "Adjusted frequency outside finite positive numerical domain","numerical_failure")
+    risk=aggregate(Risk(currency=finance["currency"],scenarios=[RiskScenario(scenario_id="level2_component",
+        annual_failure_frequency=occurrence,equipment_area_m2=area["equipment_area_m2"],personnel_area_m2=area["personnel_area_m2"],
+        financial_consequence=finance["financial_consequence"])]))
+    return {"integration_scope":"supplied_level2_event_probabilities_areas_and_damage",
+            "management_factor":fms,**area,**finance,**risk}

api581/lining.py

@@ -0,0 +1,173 @@
+"""2016 lining tables, qualified inspection-age policy and governing thinning."""
+from datetime import date
+import math
+from typing import Literal
+from pydantic import Field
+from .core import Model, NonNegative, calculation, ensure, finite_tree
+from .cracking import LiningAdjustment, lining_adjust
+
+LiningType = Literal["strip_lined_resistant_alloy","castable_refractory","castable_refractory_severe",
+    "glass_lined","acid_brick","fiberglass","organic_low_quality","organic_medium_quality","organic_high_quality"]
+Lookup = Literal["exact_rows_only","linear_between_rows","conservative_upper_row"]
+FirstYear = Literal["reject_below_first_year","qualified_first_year_value"]
+_INORGANIC = (
+    (.3,.5,9,3,.01,1),(.5,1,40,4,.03,1),(.7,2,146,6,.05,1),(1,4,428,7,.15,1),
+    (1,9,1017,9,1,1),(2,16,1978,11,1,1),(3,30,3000,13,1,2),(4,53,3000,16,1,3),
+    (6,89,3000,20,2,7),(9,146,3000,25,3,13),(12,230,3000,30,4,26),(16,351,3000,36,5,47),
+    (22,518,3000,44,7,82),(30,738,3000,53,9,139),(40,1017,3000,63,11,228),
+    (53,1358,3000,75,15,359),(69,1758,3000,89,19,548),(89,2209,3000,105,25,808),
+    (115,2697,3000,124,31,1151),(146,3000,3000,146,40,1587),(184,3000,3000,170,50,2119),
+    (230,3000,3000,199,63,2743),(286,3000,3000,230,78,3000),(351,3000,3000,266,97,3000),
+    (428,3000,3000,306,119,3000))
+_ORGANIC = ((30,1,.1),(89,4,.13),(230,16,.15),(518,53,.17),(1017,146,.2),(1758,351,1),
+    (2697,738,4),(3000,1358,16),(3000,2209,53),(3000,3000,146),(3000,3000,351),
+    (3000,3000,738),(3000,3000,1358),(3000,3000,2209))+((3000,3000,3000),)*11
+
+
+class LiningInspection(Model):
+    inspection_id: str = Field(min_length=1)
+    inspected_on: date
+    effectiveness: Literal["a","b","c","d","e"]
+    qualified_for_age_reset: bool
+    qualification_basis: str | None = None
+
+
+class LiningAge(Model):
+    lining_family: Literal["inorganic","organic"]
+    installed_on: date
+    evaluated_on: date
+    inspections: list[LiningInspection] = Field(default_factory=list,max_length=10000)
+    age_basis_policy: Literal["step1_installation_or_last_ab","figure51_organic_service_only"]
+    year_length_days: Literal[365,365.25]
+
+
+@calculation("damage/lining-effective-age", "Lining age from installation or qualified A/B inspection", LiningAge,
+    ["Part2 §§5.5.2-5.5.3 STEP1,Table5.3,Figure5.1; PDF pp166,168,171"],limitations=[
+        "STEP1 permits installation or last A/B inspection baseline; organic table/figure also say years in service. Explicit policy chooses STEP1 reset or organic service-only interpretation, not an asserted erratum. No inspection-count/Bayesian credit. Owner qualifies A/B reset applicability under Annex2.C.6; C/D/E cannot reset. Date-only deterministic elapsed days divided by explicit365 or365.25; no inferred current clock, time zone or service downtime subtraction."])
+def effective_age(x):
+    ensure(x.evaluated_on >= x.installed_on,"Evaluation date precedes installation")
+    ensure(x.age_basis_policy != "figure51_organic_service_only" or x.lining_family == "organic","Service-only figure interpretation applies only to organic lining")
+    ensure(len({i.inspection_id for i in x.inspections}) == len(x.inspections),"Duplicate lining inspection identifier")
+    eligible = []
+    for i in x.inspections:
+        ensure(bool(i.inspection_id.strip()),"Inspection identifier must not be blank")
+        ensure(x.installed_on <= i.inspected_on <= x.evaluated_on,"Inspection date outside lining service/evaluation period")
+        if i.qualified_for_age_reset:
+            ensure(i.effectiveness in ("a","b") and i.qualification_basis is not None and bool(i.qualification_basis.strip()),"Age reset requires qualified A/B inspection and basis")
+            eligible.append(i)
+        else:
+            ensure(i.qualification_basis is None,"Unqualified reset cannot carry qualification basis")
+    latest = max(eligible,key=lambda i:(i.inspected_on,i.inspection_id),default=None)
+    reset = latest if x.age_basis_policy == "step1_installation_or_last_ab" else None
+    baseline = reset.inspected_on if reset is not None else x.installed_on
+    return {"effective_age_years":(x.evaluated_on-baseline).days/x.year_length_days,
+        "elapsed_service_years":(x.evaluated_on-x.installed_on).days/x.year_length_days,
+        "age_baseline_date":baseline.isoformat(),"age_baseline_source":"qualified_ab_inspection" if reset else "installation",
+        "reset_inspection_id":reset.inspection_id if reset else None,"qualified_ab_inspection_count":len(eligible),
+        "age_basis_policy":x.age_basis_policy}
+
+
+class LiningBase(Model):
+    lining_type: LiningType
+    age_years: NonNegative
+    lookup_policy: Lookup
+    first_year_policy: FirstYear
+    first_year_qualification_basis: str | None = None
+
+
+@calculation("damage/lining-base-factor", "Inorganic and organic lining base damage factor tables", LiningBase,
+    ["Part2 Tables5.4-5.5; PDF pp169-170"],limitations=[
+        "All225 cells:6 inorganic/3 organic columns over1..25years. Fiberglass follows source Table5.4 grouping without inferring chemical classification. Organic quality includes stated application/reinforcement thickness, not material name alone. No >25year extrapolation even if selected column plateaus. Between-year numerical policy explicit; source gives no interpolation instruction. Below1year requires rejection or qualified first-year-value policy, never silently zero damage or invented age0 row."])
+def base_factor(x):
+    qualified = x.first_year_policy == "qualified_first_year_value"
+    ensure((x.first_year_qualification_basis is not None and bool(x.first_year_qualification_basis.strip())) if qualified else x.first_year_qualification_basis is None,
+        "First-year policy and qualification basis must agree")
+    ensure(x.age_years <= 25,"Lining age exceeds25year source table; no extrapolation","lining_table_age_exceeded")
+    ensure(x.age_years >= 1 or qualified,"Lining age below1year requires qualified first-year policy","lining_age_below_first_row")
+    age = max(x.age_years,1.)
+    col = LiningType.__args__.index(x.lining_type)
+    table, col = (_INORGANIC,col) if col < 6 else (_ORGANIC,col-6)
+    low, high = math.floor(age),math.ceil(age)
+    weight = age-low
+    ensure(low == high or x.lookup_policy != "exact_rows_only","Age lies between table rows; numerical policy required","lining_age_between_rows")
+    value = float(table[high-1][col]) if x.lookup_policy == "conservative_upper_row" else table[low-1][col]+weight*(table[high-1][col]-table[low-1][col])
+    return {"base_damage_factor":value,"lower_age_row_years":float(low),"upper_age_row_years":float(high),
+        "age_interpolation_weight":weight,"first_year_value_used":x.age_years < 1,"source_table":"5.4" if table is _INORGANIC else "5.5"}
+
+
+class LiningCondition(Model):
+    condition: Literal["good","average","poor"]
+
+
+@calculation("damage/lining-condition-factor", "Qualitative lining condition factor", LiningCondition,
+    ["Part2 Table5.6; PDF p171"],limitations=[
+        "Owner classifies good: like new/no attack/no repairs; average: no excessive attack with successful good-quality local repairs; poor: prior failures/imminent failure conditions or unsuccessful/poor repairs. No automatic classification from a single damage flag or image."])
+def condition_factor(x):
+    return {"condition_factor":{"good":1.,"average":2.,"poor":10.}[x.condition]}
+
+
+class LiningMonitoring(Model):
+    monitoring_used: bool
+    known_effective_for_lining_deterioration: bool
+    effectiveness_basis: str | None = None
+
+
+@calculation("damage/lining-monitoring-factor", "Lining early-detection monitoring credit", LiningMonitoring,
+    ["Part2 §5.5.3 STEP3(2); PDF p167"],limitations=[
+        "Factor.1 only when monitoring is used and known effective for detecting lining deterioration early enough for orderly shutdown; otherwise1. Owner supplies effectiveness basis. Merely installed sensors do not prove efficacy. Unlike thinning FOM, lining factor multiplies DF, not divides; no stacked methods."])
+def monitoring_factor(x):
+    if x.known_effective_for_lining_deterioration:
+        ensure(x.monitoring_used and x.effectiveness_basis is not None and bool(x.effectiveness_basis.strip()),"Effective lining monitoring requires use and qualification basis")
+    else:
+        ensure(x.effectiveness_basis is None,"Unverified monitoring cannot claim effectiveness basis")
+    return {"monitoring_factor":.1 if x.known_effective_for_lining_deterioration else 1.}
+
+
+class GoverningLining(Model):
+    base_material_thinning_damage_factor: NonNegative
+    lining_damage_factor: NonNegative
+
+
+@calculation("damage/lining-governing-thinning", "Minimum of base-material thinning and lining damage factors", GoverningLining,
+    ["Part2 §5.5.1 and eq(2.2); PDF pp142,166"],limitations=[
+        "Compares lining DF to base-material thinning DF as source instructs. Not total DF: other applicable damage mechanisms require separate combination. No automatic zero/thinning applicability assumption or additional.1 floor on lining DF."])
+def governing_thinning(x):
+    return {"governing_thinning_damage_factor":min(x.base_material_thinning_damage_factor,x.lining_damage_factor),
+        "governing_source":"equal" if x.base_material_thinning_damage_factor == x.lining_damage_factor else "lining" if x.lining_damage_factor < x.base_material_thinning_damage_factor else "base_material_thinning"}
+
+
+class LiningAssessment(Model):
+    lining_type: LiningType
+    applicability_basis: str = Field(min_length=1)
+    organic_compatible_with_environment: bool | None = None
+    organic_within_design_temperature_including_steamout: bool | None = None
+    organic_properly_applied_and_cured: bool | None = None
+    age: LiningAge
+    lookup_policy: Lookup
+    first_year_policy: FirstYear
+    first_year_qualification_basis: str | None = None
+    condition: LiningCondition
+    monitoring: LiningMonitoring
+    base_material_thinning_damage_factor: NonNegative
+    base_material_thinning_basis: str = Field(min_length=1)
+
+
+@calculation("damage/lining-assessment", "Compose lining age base factor condition monitoring and governing thinning", LiningAssessment,
+    ["Part2 §§5.1-5.5,eq(2.24),Tables5.4-5.6,Figure5.1; PDF pp166-171"],origin="api581_composition_with_explicit_age_policies",limitations=[
+        "Compatible protective lining must be owner-qualified. Organic compatibility, temperature including steamout and proper application/curing must all be affirmed; false/unknown rejects source-assumption credit. Date history only resets per explicit source-interpretation policy and qualified A/B inspection. No automatic inspection-method classification or actual lining degradation-rate model. Base tables1..25years; interpolation/first-year policies explicit. LiningDF=base*condition*monitoring, then governing thinning=min(base-metal thinningDF,liningDF), not sum or product of both DFs. No.1 floor or automatic all-mechanism DF. Cladding/overlay sequential wall-loss calculations are distinct."])
+def assessment(x):
+    ensure(bool(x.applicability_basis.strip()) and bool(x.base_material_thinning_basis.strip()),"Applicability and base-material thinning basis must be nonblank")
+    organic = x.lining_type.startswith("organic_")
+    ensure(x.age.lining_family == ("organic" if organic else "inorganic"),"Lining type and age family must agree with source table grouping")
+    flags = (x.organic_compatible_with_environment,x.organic_within_design_temperature_including_steamout,x.organic_properly_applied_and_cured)
+    ensure(all(v is True for v in flags) if organic else all(v is None for v in flags),"Organic assumptions must all be affirmed for organic lining and omitted for inorganic table types")
+    age = effective_age(x.age)
+    base = base_factor(LiningBase(lining_type=x.lining_type,age_years=age["effective_age_years"],lookup_policy=x.lookup_policy,
+        first_year_policy=x.first_year_policy,first_year_qualification_basis=x.first_year_qualification_basis))
+    condition, monitoring = condition_factor(x.condition),monitoring_factor(x.monitoring)
+    # Reuse the established eq2.24 calculation after the stronger qualification gates.
+    result = lining_adjust(LiningAdjustment(base_damage_factor=base["base_damage_factor"],condition=x.condition.condition,
+        effective_online_monitoring=monitoring["monitoring_factor"] == .1))
+    finite_tree(result)
+    governing = governing_thinning(GoverningLining(base_material_thinning_damage_factor=x.base_material_thinning_damage_factor,lining_damage_factor=result["lining_damage_factor"]))
+    return {**age,**base,**condition,**monitoring,**result,**governing,"base_material_thinning_damage_factor":x.base_material_thinning_damage_factor}

api581/native_toxic.py

@@ -0,0 +1,67 @@
+"""Qualified historical toxic criterion -> native long-duration pure-species pool."""
+from typing import Literal
+from pydantic import Field, model_validator
+from .core import Model, Positive, Fraction, REGISTRY, calculation, ensure, finite_tree
+from .slabx_adapter import NativeSubstance, NativeAtmosphere, NativePoolFootprint, native_pool_footprint
+from .toxic_criteria import ToxicCriterion, select_criterion
+from .toxic_level2 import ToxicDuration, toxic_duration, ToxicCloudArea, ToxicCase, toxic_case
+
+
+class ToxicPoolSource(Model):
+    substance: NativeSubstance
+    atmosphere: NativeAtmosphere
+    vapor_source_rate_kg_s: Positive
+    source_area_m2: Positive
+    available_mass_kg: Positive
+    detection_maximum_duration_s: Positive
+    receptor_height_m: Literal[0.0]
+    plume_distance_limit_m: Positive = Field(le=1e6)
+    puff_time_limit_s: Positive | None = None
+    puff_steps: int = Field(default=40,ge=10,le=1000,strict=True)
+    crosswind_half_span_m: Positive
+    crosswind_points_per_side: int = Field(default=65,ge=3,le=501,strict=True)
+    source_qualification: str = Field(min_length=1,max_length=1000)
+    meander_closure: Literal["ermak","sigma_theta"]
+    timeout_s: Positive = Field(default=120,le=600)
+
+    @model_validator(mode="after")
+    def qualification(self):
+        if not self.source_qualification.strip() or not self.substance.property_source.strip():
+            raise ValueError("Source and property qualifications must be nonblank")
+        return self
+
+
+class NativeToxicPool(Model):
+    criterion: ToxicCriterion
+    source: ToxicPoolSource
+    non_ignition_probability: Fraction
+    exposure_model_basis: Literal["constant_exposure_equivalent_native_time_average"]
+
+
+@calculation("dispersion/native-pool-toxic-consequence", "Historical toxic criterion through native pure-pool footprint and conditional toxic consequence", NativeToxicPool,
+    ["Part3 §§5.9.2-5.9.6,eqs(3.186)-(3.189); PDF pp565-567", "SLABx1.0.8 native time-averaged planar field"],
+    origin="api581_criterion_to_native_time_average_toxic_screen",
+    limitations=[*REGISTRY["consequence/select-toxic-criterion"].limitations,
+        "Pure species only: selected fluid_id must equal native substance.fluid_id and toxic mole fraction must be1. Mixture criteria remain callable independently but mixture thermodynamics/species-resolved source mapping is not inferred. Uses native slabx1.0.8 ground-level constant vapor pool with explicit properties/atmosphere/spatial grid; no automatic LH2 toxicity or asphyxiation model.",
+        "Eq3.186 bounds source duration by3600s,inventory/rate,detection duration. Selected exposure window must not exceed this source duration; native averaging equals that exposure. Short pulses fail explicitly, not zero consequence. Constant-exposure-equivalent TWA is a declared engineering screening assumption: nonlinear probit dose from C(t) is not generally equal to dose from average C. Native cloud passage does not prove time-above-threshold at every receptor.",
+        "Ground-level receptor height0 is required by §5.9.6. Censored/premise-invalid spatial footprints fail before toxic consequence. Valid sampled area is multiplied by non-ignition probability exactly once, with toxic equipment area0 per eq3.188. No mixture maximum, additional event/GFF weighting or actual exposure-history/dose integration beyond this single pure component. Historical criteria are not current exposure advice or model/site certification."])
+def native_toxic_pool(x):
+    ensure(x.criterion.toxic_mole_fraction == 1,"Native pure-pool toxic bridge requires mole fraction1","unsupported_mixture_source")
+    ensure(x.criterion.fluid_id == x.source.substance.fluid_id,"Toxic species and native substance id must match","toxic_species_mismatch")
+    selected = select_criterion(x.criterion)
+    finite_tree(selected)
+    ensure(selected["component_present"] and selected["attainable_in_mixture"],"Selected toxic criterion is not physically attainable","toxic_criterion_unattainable")
+    duration = toxic_duration(ToxicDuration(available_mass_kg=x.source.available_mass_kg,
+        mixture_release_rate_kg_s=x.source.vapor_source_rate_kg_s,detection_maximum_duration_s=x.source.detection_maximum_duration_s))
+    ensure(duration["release_duration_s"] >= x.criterion.exposure_duration_s,
+        "Source duration shorter than selected exposure window; transient exposure model required","toxic_exposure_duration_unsupported")
+    values = x.source.model_dump(exclude={"available_mass_kg","detection_maximum_duration_s"})
+    native = native_pool_footprint(NativePoolFootprint(**values,engine="slabx",lh2_plume_width_coupling=False,
+        release_duration_s=duration["release_duration_s"],averaging_time_s=x.criterion.exposure_duration_s,
+        threshold_volume_fraction=selected["threshold_volume_fraction"],threshold_source=selected["criterion_source"]))
+    ensure(native["threshold_area_m2"] is not None,"Native toxic footprint unusable: "+native["footprint_status"],"dispersion_footprint_unusable")
+    toxic = toxic_case(ToxicCase(components=[ToxicCloudArea(component_id=x.criterion.fluid_id,
+        selected_criterion_source=selected["criterion_source"],cloud_area_m2=native["threshold_area_m2"])],
+        non_ignition_probability=x.non_ignition_probability))
+    return {**native,**selected,**toxic,"release_duration_s":duration["release_duration_s"],
+        "release_duration_governing_limit":duration["governing_limit"],"exposure_model_basis":x.exposure_model_basis}