api581-engine 0.1.4__py3-none-any.whl

api581/amine_screening.py

@@ -0,0 +1,103 @@
+"""Amine SCC screening; susceptibility remains separately qualified."""
+from typing import Literal
+from pydantic import Field
+from .core import Model, Positive, NonNegative, calculation, ensure
+from .scc_mechanisms import Assessment, InspectionCounts, assess
+
+
+class AmineCrackingScreen(Model):
+    material: Literal['carbon_steel','low_alloy_steel','other_material']
+    acid_gas_treating_amine_present: bool
+    screening_basis: str = Field(min_length=1)
+
+
+@calculation('damage/amine-cracking-screening','Any-concentration acid-gas-treating amine SCC material screen',AmineCrackingScreen,
+    ['Part2 §7.3; PDF p179'],limitations=[
+        'Carbon/low-alloy steel with acid-gas-treating amines in any concentration requires susceptibility evaluation. No concentration, normal-temperature, amine-type, rich-service or PWHT exclusion is inferred. Lean/rich/fresh composition, actual metal temperature, heat tracing, steam-out and other cracking mechanisms require separate evaluation. Screen-out is outside this procedure, not overall immunity or DF0.'])
+def amine_cracking_screening(x):
+    ensure(bool(x.screening_basis.strip()),'Qualified material and acid-gas-treating amine exposure basis required')
+    material=x.material!='other_material'
+    return {'evaluate_amine_cracking':material and x.acid_gas_treating_amine_present,
+        'screening_reason':'evaluate' if material and x.acid_gas_treating_amine_present else
+            'outside_material_scope' if not material else 'treating_amine_absent'}
+
+
+class ScreenedAmineCracking(Model):
+    screening: AmineCrackingScreen
+    cracking: Assessment
+    susceptibility_and_inspection_basis: str = Field(min_length=1)
+
+
+@calculation('damage/amine-cracking-screened-assessment','Screened amine exposure through qualified SCC susceptibility and DF',ScreenedAmineCracking,
+    ['Part2 §§7.3,7.5-7.6; Table7.2,Table6.3; eq(2.26); PDF pp179-181'],
+    origin='amine_material_exposure_screen_to_supplied_susceptibility_df',limitations=[
+        'Supplied susceptibility must be independently qualified using Figure7.1 or expert assessment; this API does not implement the figure or predict from amine chemistry. Screening must pass; no synthetic zero DF on screen-out. Confirmed cracking forces High; unrepaired cracks require FFS. Inspection grade/count and time since qualifying A/B/C clear/repaired inspection follow section7.6.3 and remain externally qualified. Existing six-equivalent-inspection support is retained; no all-mechanism assessment.'])
+def amine_cracking_screened_assessment(x):
+    ensure(not x.cracking.unrepaired_cracks,'Unrepaired amine cracks require separate FFS evaluation','ffs_required')
+    ensure(bool(x.susceptibility_and_inspection_basis.strip()),'Amine susceptibility and mechanism-specific inspection basis required')
+    screen=amine_cracking_screening(x.screening)
+    ensure(screen['evaluate_amine_cracking'],'Amine material/exposure screen not met','amine_outside_screen')
+    return {**screen,**assess('amine',x.cracking)}
+
+
+class AmineFigure(Model):
+    confirmed_cracking: bool
+    unrepaired_cracks: bool
+    stress_relieved: bool
+    solution: Literal['fresh','rich','lean','lean_and_rich']
+    amine_group: Literal['mea_or_dipa','dea','other_treating_amine']
+    maximum_metal_temperature_k: Positive
+    heat_traced: bool
+    steamed_out_before_water_flush: bool
+    applicability_basis: str = Field(min_length=1)
+
+
+@calculation('damage/amine-figure-susceptibility','Figure7.1 amine cracking susceptibility',AmineFigure,
+    ['Part2 Figure7.1,Table7.1; PDF pp182-183'],limitations=[
+        'Literal Fahrenheit flowchart thresholds100/140/180F converted exactly to kelvin.100..180 and140..180 include endpoints after the prior >180 test. Both lean/rich exposure routes lean per Table7.1. Other treating amines follow the printed not-MEA/DIPA/not-DEA branch; mixtures spanning groups require independent qualification, not automatic worst-group selection. Actual maximum metal temperature, heat tracing, steam-out before flushing and effective stress relief require qualification. Confirmed cracks forceHigh before stress relief/composition; unrepaired cracks require FFS. Not an amine corrosion-rate model or automatic chemical speciation/PWHT validation.'])
+def amine_figure_susceptibility(x):
+    ensure(not x.unrepaired_cracks,'Unrepaired amine cracks require separate FFS evaluation','ffs_required')
+    ensure(bool(x.applicability_basis.strip()),'Qualified amine composition, actual metal temperature and fabrication basis required')
+    if x.confirmed_cracking:
+        level,branch='high','confirmed_cracking'
+    elif x.stress_relieved:
+        level,branch='none','stress_relieved'
+    elif x.solution in ('fresh','rich'):
+        level,branch='none','not_exposed_to_lean_amine'
+    else:
+        # Compare in kelvin to avoid back-conversion roundoff at printed endpoints.
+        t=x.maximum_metal_temperature_k
+        f100,f140,f180=((f-32)*5/9+273.15 for f in (100.,140.,180.))
+        heated=x.heat_traced or x.steamed_out_before_water_flush
+        if x.amine_group=='mea_or_dipa':
+            level='high' if t>f180 else 'medium' if t>=f100 or heated else 'low'
+        elif x.amine_group=='dea':
+            level='medium' if t>f180 else 'low' if t>=f140 or heated else 'none'
+        else:
+            level='low' if t>f180 or heated else 'none'
+        branch=x.amine_group+'_lean'
+    return {'susceptibility':level,'decision_branch':branch,
+        'lean_exposure_selected':x.solution in ('lean','lean_and_rich')}
+
+
+class FigureAmineAssessment(Model):
+    screening: AmineCrackingScreen
+    service: AmineFigure
+    years_since_qualifying_inspection: NonNegative
+    inspections: InspectionCounts
+    inspection_basis: str = Field(min_length=1)
+
+
+@calculation('damage/amine-figure-assessment','Figure7.1 susceptibility through amine SCC DF',FigureAmineAssessment,
+    ['Part2 §7.6.3,Figure7.1,Tables7.2/6.3,eq(2.26); PDF pp180,182-183'],
+    origin='amine_flowchart_to_existing_scc_df',limitations=[
+        'Material/exposure screen, Figure7.1 service declarations and mechanism-specific qualifying inspection age/count require qualification. Reuses existing SVI, equivalent inspection and age escalation, with maximum supported equivalent count6. Rich/fresh none applies only to this amine SCC mechanism, not SSC/HIC/SOHIC or other damage. No whole-component risk, FFS or automatic inspection grading.'])
+def amine_figure_assessment(x):
+    selected=amine_figure_susceptibility(x.service)
+    ensure(bool(x.inspection_basis.strip()),'Amine-specific qualifying inspection period and effectiveness basis required')
+    screen=amine_cracking_screening(x.screening)
+    ensure(screen['evaluate_amine_cracking'],'Amine material/exposure screen not met','amine_outside_screen')
+    result=assess('amine',Assessment(susceptibility=selected['susceptibility'],confirmed_cracking=x.service.confirmed_cracking,
+        unrepaired_cracks=x.service.unrepaired_cracks,years_since_qualifying_inspection=x.years_since_qualifying_inspection,
+        inspections=x.inspections))
+    return {**screen,**selected,**result}

api581/api/__init__.py

@@ -0,0 +1,4 @@
+"""Typed public Python APIs grouped by engineering domain."""
+from . import api520, bundle, consequence, damage, dispersion, effects, events, financial, frequency, inspection, level1, level2, planning, prd, properties, release, reliability, risk, tank
+
+__all__ = ['api520', 'bundle', 'consequence', 'damage', 'dispersion', 'effects', 'events', 'financial', 'frequency', 'inspection', 'level1', 'level2', 'planning', 'prd', 'properties', 'release', 'reliability', 'risk', 'tank']

api581/api/api520.py

@@ -0,0 +1,88 @@
+"""Public api520 calculations. Inputs and outputs use named SI units.
+Generated by scripts/build_python_api.py; inspect the request model for fields.
+"""
+from ..core import Context
+from ..result import CalculationResult, calculate
+
+
+from ..api520 import CriticalRatio as CriticalPressureRatioInput
+from ..outputs import Api520CriticalPressureRatioOutput as CriticalPressureRatioOutput
+
+def critical_pressure_ratio(inputs: CriticalPressureRatioInput, *, context: Context | None = None) -> CalculationResult[CriticalPressureRatioOutput]:
+    'API 520 critical-flow pressure ratio'
+    return calculate('api520/critical-pressure-ratio', inputs, output_type=CriticalPressureRatioOutput, context=context)
+
+
+from ..api520 import FlowCoefficient as FlowCoefficientCInput
+from ..outputs import Api520FlowCoefficientCOutput as FlowCoefficientCOutput
+
+def flow_coefficient_c(inputs: FlowCoefficientCInput, *, context: Context | None = None) -> CalculationResult[FlowCoefficientCOutput]:
+    'API 520 gas/vapor flow coefficient C'
+    return calculate('api520/flow-coefficient-c', inputs, output_type=FlowCoefficientCOutput, context=context)
+
+
+from ..api520 import RelievingPressure as RelievingPressureInput
+from ..outputs import Api520RelievingPressureOutput as RelievingPressureOutput
+
+def relieving_pressure(inputs: RelievingPressureInput, *, context: Context | None = None) -> CalculationResult[RelievingPressureOutput]:
+    'API 520 relieving pressure'
+    return calculate('api520/relieving-pressure', inputs, output_type=RelievingPressureOutput, context=context)
+
+
+from ..api520 import GasCriticalArea as GasCriticalAreaInput
+from ..outputs import Api520GasCriticalAreaOutput as GasCriticalAreaOutput
+
+def gas_critical_area(inputs: GasCriticalAreaInput, *, context: Context | None = None) -> CalculationResult[GasCriticalAreaOutput]:
+    'API 520 critical gas/vapor effective area'
+    return calculate('api520/gas-critical-area', inputs, output_type=GasCriticalAreaOutput, context=context)
+
+
+from ..api520 import GasSubcriticalArea as GasSubcriticalAreaInput
+from ..outputs import Api520GasSubcriticalAreaOutput as GasSubcriticalAreaOutput
+
+def gas_subcritical_area(inputs: GasSubcriticalAreaInput, *, context: Context | None = None) -> CalculationResult[GasSubcriticalAreaOutput]:
+    'API 520 subcritical gas/vapor effective area'
+    return calculate('api520/gas-subcritical-area', inputs, output_type=GasSubcriticalAreaOutput, context=context)
+
+
+from ..api520 import LiquidArea as LiquidAreaInput
+from ..outputs import Api520LiquidAreaOutput as LiquidAreaOutput
+
+def liquid_area(inputs: LiquidAreaInput, *, context: Context | None = None) -> CalculationResult[LiquidAreaOutput]:
+    'API 520 liquid relief effective area'
+    return calculate('api520/liquid-area', inputs, output_type=LiquidAreaOutput, context=context)
+
+
+from ..api520 import ViscosityFactor as LiquidViscosityFactorInput
+from ..outputs import Api520LiquidViscosityFactorOutput as LiquidViscosityFactorOutput
+
+def liquid_viscosity_factor(inputs: LiquidViscosityFactorInput, *, context: Context | None = None) -> CalculationResult[LiquidViscosityFactorOutput]:
+    'API 520 liquid viscosity correction Kv'
+    return calculate('api520/liquid-viscosity-factor', inputs, output_type=LiquidViscosityFactorOutput, context=context)
+
+
+from ..api520 import GasCriticalCapacity as GasCriticalCapacityInput
+from ..outputs import Api520GasCriticalCapacityOutput as GasCriticalCapacityOutput
+
+def gas_critical_capacity(inputs: GasCriticalCapacityInput, *, context: Context | None = None) -> CalculationResult[GasCriticalCapacityOutput]:
+    'API 520 critical gas/vapor mass capacity'
+    return calculate('api520/gas-critical-capacity', inputs, output_type=GasCriticalCapacityOutput, context=context)
+
+
+from ..api520 import GasSubcriticalCapacity as GasSubcriticalCapacityInput
+from ..outputs import Api520GasSubcriticalCapacityOutput as GasSubcriticalCapacityOutput
+
+def gas_subcritical_capacity(inputs: GasSubcriticalCapacityInput, *, context: Context | None = None) -> CalculationResult[GasSubcriticalCapacityOutput]:
+    'API 520 subcritical gas/vapor mass capacity'
+    return calculate('api520/gas-subcritical-capacity', inputs, output_type=GasSubcriticalCapacityOutput, context=context)
+
+
+from ..api520 import LiquidCapacity as LiquidCapacityInput
+from ..outputs import Api520LiquidCapacityOutput as LiquidCapacityOutput
+
+def liquid_capacity(inputs: LiquidCapacityInput, *, context: Context | None = None) -> CalculationResult[LiquidCapacityOutput]:
+    'API 520 liquid relief volumetric capacity'
+    return calculate('api520/liquid-capacity', inputs, output_type=LiquidCapacityOutput, context=context)
+
+
+__all__ = ['critical_pressure_ratio', 'CriticalPressureRatioInput', 'CriticalPressureRatioOutput', 'flow_coefficient_c', 'FlowCoefficientCInput', 'FlowCoefficientCOutput', 'relieving_pressure', 'RelievingPressureInput', 'RelievingPressureOutput', 'gas_critical_area', 'GasCriticalAreaInput', 'GasCriticalAreaOutput', 'gas_subcritical_area', 'GasSubcriticalAreaInput', 'GasSubcriticalAreaOutput', 'liquid_area', 'LiquidAreaInput', 'LiquidAreaOutput', 'liquid_viscosity_factor', 'LiquidViscosityFactorInput', 'LiquidViscosityFactorOutput', 'gas_critical_capacity', 'GasCriticalCapacityInput', 'GasCriticalCapacityOutput', 'gas_subcritical_capacity', 'GasSubcriticalCapacityInput', 'GasSubcriticalCapacityOutput', 'liquid_capacity', 'LiquidCapacityInput', 'LiquidCapacityOutput']

api581/api/bundle.py

@@ -0,0 +1,121 @@
+"""Public bundle calculations. Inputs and outputs use named SI units.
+Generated by scripts/build_python_api.py; inspect the request model for fields.
+"""
+from ..core import Context
+from ..result import CalculationResult, calculate
+
+from ..bundle import LifeRecord as LifeRecordInput
+
+from ..bundle import BundleHistory as WeibayesHistoryInput
+from ..outputs import BundleWeibayesHistoryOutput as WeibayesHistoryOutput
+
+def weibayes_history(inputs: WeibayesHistoryInput, *, context: Context | None = None) -> CalculationResult[WeibayesHistoryOutput]:
+    'Fixed-shape bundle Weibayes life estimate'
+    return calculate('bundle/weibayes-history', inputs, output_type=WeibayesHistoryOutput, context=context)
+
+
+from ..bundle import BundleConditionUpdate as ConditionUpdateInput
+from ..outputs import BundleConditionUpdateOutput as ConditionUpdateOutput
+
+def condition_update(inputs: ConditionUpdateInput, *, context: Context | None = None) -> CalculationResult[ConditionUpdateOutput]:
+    'Add inspection-predicted bundle failure point'
+    return calculate('bundle/condition-update', inputs, output_type=ConditionUpdateOutput, context=context)
+
+
+from ..bundle import BundleThicknessLife as ThicknessLifeInput
+from ..outputs import BundleThicknessLifeOutput as ThicknessLifeOutput
+
+def thickness_life(inputs: ThicknessLifeInput, *, context: Context | None = None) -> CalculationResult[ThicknessLifeOutput]:
+    'Inspection-based tube thinning and predicted life'
+    return calculate('bundle/thickness-life', inputs, output_type=ThicknessLifeOutput, context=context)
+
+
+from ..bundle import BundleEstimatedLife as EstimatedLifeInput
+from ..outputs import BundleEstimatedLifeOutput as EstimatedLifeOutput
+
+def estimated_life(inputs: EstimatedLifeInput, *, context: Context | None = None) -> CalculationResult[EstimatedLifeOutput]:
+    'Predicted bundle life from estimated remaining life'
+    return calculate('bundle/estimated-life', inputs, output_type=EstimatedLifeOutput, context=context)
+
+
+from ..bundle import BundleLifeExtension as LifeExtensionInput
+from ..outputs import BundleLifeExtensionOutput as LifeExtensionOutput
+
+def life_extension(inputs: LifeExtensionInput, *, context: Context | None = None) -> CalculationResult[LifeExtensionOutput]:
+    'Effective bundle age after life-extension action'
+    return calculate('bundle/life-extension', inputs, output_type=LifeExtensionOutput, context=context)
+
+
+from ..bundle import BundleConsequence as ConsequenceInput
+from ..outputs import BundleConsequenceOutput as ConsequenceOutput
+
+def consequence(inputs: ConsequenceInput, *, context: Context | None = None) -> CalculationResult[ConsequenceOutput]:
+    'Bundle failure or planned replacement financial consequence'
+    return calculate('bundle/consequence', inputs, output_type=ConsequenceOutput, context=context)
+
+
+from ..bundle import BundleRisk as RiskInput
+from ..outputs import BundleRiskOutput as RiskOutput
+
+def risk(inputs: RiskInput, *, context: Context | None = None) -> CalculationResult[RiskOutput]:
+    'Bundle unreliability-weighted consequence'
+    return calculate('bundle/risk', inputs, output_type=RiskOutput, context=context)
+
+
+from ..bundle import BundleTarget as TargetAgeInput
+from ..outputs import BundleTargetAgeOutput as TargetAgeOutput
+
+def target_age(inputs: TargetAgeInput, *, context: Context | None = None) -> CalculationResult[TargetAgeOutput]:
+    'Bundle age at owner probability-weighted risk target'
+    return calculate('bundle/target-age', inputs, output_type=TargetAgeOutput, context=context)
+
+
+from ..bundle import BundleDeferral as DeferralDecisionInput
+from ..outputs import BundleDeferralDecisionOutput as DeferralDecisionOutput
+
+def deferral_decision(inputs: DeferralDecisionInput, *, context: Context | None = None) -> CalculationResult[DeferralDecisionOutput]:
+    'Conditional incremental risk and inspection/replacement economics'
+    return calculate('bundle/deferral-decision', inputs, output_type=DeferralDecisionOutput, context=context)
+
+
+from ..bundle import BundleReplacement as ReplacementOptimizationInput
+from ..outputs import BundleReplacementOptimizationOutput as ReplacementOptimizationOutput
+
+def replacement_optimization(inputs: ReplacementOptimizationInput, *, context: Context | None = None) -> CalculationResult[ReplacementOptimizationOutput]:
+    'Bundle planned-replacement grid cost optimization'
+    return calculate('bundle/replacement-optimization', inputs, output_type=ReplacementOptimizationOutput, context=context)
+
+
+from ..bundle import BundleMaterial as MaterialFactorInput
+from ..outputs import BundleMaterialFactorOutput as MaterialFactorOutput
+
+def material_factor(inputs: MaterialFactorInput, *, context: Context | None = None) -> CalculationResult[MaterialFactorOutput]:
+    'Bundle replacement material cost factor'
+    return calculate('bundle/material-factor', inputs, output_type=MaterialFactorOutput, context=context)
+
+
+from ..bundle import BundleReplacementCost as ReplacementCostInput
+from ..outputs import BundleReplacementCostOutput as ReplacementCostOutput
+
+def replacement_cost(inputs: ReplacementCostInput, *, context: Context | None = None) -> CalculationResult[ReplacementCostOutput]:
+    'Volume/material-scaled bundle replacement cost'
+    return calculate('bundle/replacement-cost', inputs, output_type=ReplacementCostOutput, context=context)
+
+
+from ..bundle import BundleExtensionFactor as LifeExtensionFactorInput
+from ..outputs import BundleLifeExtensionFactorOutput as LifeExtensionFactorOutput
+
+def life_extension_factor(inputs: LifeExtensionFactorInput, *, context: Context | None = None) -> CalculationResult[LifeExtensionFactorOutput]:
+    'Suggested bundle life-extension action factor'
+    return calculate('bundle/life-extension-factor', inputs, output_type=LifeExtensionFactorOutput, context=context)
+
+
+from ..bundle import BundleCategories as CategoriesInput
+from ..outputs import BundleCategoriesOutput as CategoriesOutput
+
+def categories(inputs: CategoriesInput, *, context: Context | None = None) -> CalculationResult[CategoriesOutput]:
+    'Bundle probability and financial consequence categories'
+    return calculate('bundle/categories', inputs, output_type=CategoriesOutput, context=context)
+
+
+__all__ = ['LifeRecordInput', 'weibayes_history', 'WeibayesHistoryInput', 'WeibayesHistoryOutput', 'condition_update', 'ConditionUpdateInput', 'ConditionUpdateOutput', 'thickness_life', 'ThicknessLifeInput', 'ThicknessLifeOutput', 'estimated_life', 'EstimatedLifeInput', 'EstimatedLifeOutput', 'life_extension', 'LifeExtensionInput', 'LifeExtensionOutput', 'consequence', 'ConsequenceInput', 'ConsequenceOutput', 'risk', 'RiskInput', 'RiskOutput', 'target_age', 'TargetAgeInput', 'TargetAgeOutput', 'deferral_decision', 'DeferralDecisionInput', 'DeferralDecisionOutput', 'replacement_optimization', 'ReplacementOptimizationInput', 'ReplacementOptimizationOutput', 'material_factor', 'MaterialFactorInput', 'MaterialFactorOutput', 'replacement_cost', 'ReplacementCostInput', 'ReplacementCostOutput', 'life_extension_factor', 'LifeExtensionFactorInput', 'LifeExtensionFactorOutput', 'categories', 'CategoriesInput', 'CategoriesOutput']

api581/api/consequence.py

@@ -0,0 +1,102 @@
+"""Public consequence calculations. Inputs and outputs use named SI units.
+Generated by scripts/build_python_api.py; inspect the request model for fields.
+"""
+from ..core import Context
+from ..result import CalculationResult, calculate
+
+from ..toxic_criteria import CriterionCandidate as CriterionCandidateInput
+from ..consequences import HoleValue as HoleValueInput
+from ..physical_explosion import NfntFrequencyCase as NfntFrequencyCaseInput
+from ..risk import Outcome as OutcomeInput
+from ..toxic_level2 import ToxicCloudArea as ToxicCloudAreaInput
+from ..toxic_level2 import ToxicFrequencyCase as ToxicFrequencyCaseInput
+
+from ..effects import EmpiricalArea as PowerLawAreaInput
+from ..outputs import ConsequencePowerLawAreaOutput as PowerLawAreaOutput
+
+def power_law_area(inputs: PowerLawAreaInput, *, context: Context | None = None) -> CalculationResult[PowerLawAreaOutput]:
+    'Level 1 consequence power-law primitive'
+    return calculate('consequence/power-law-area', inputs, output_type=PowerLawAreaOutput, context=context)
+
+
+from ..risk import Consequences as ExpectedInput
+from ..outputs import ConsequenceExpectedOutput as ExpectedOutput
+
+def expected(inputs: ExpectedInput, *, context: Context | None = None) -> CalculationResult[ExpectedOutput]:
+    'Conditional event-weighted consequence'
+    return calculate('consequence/expected', inputs, output_type=ExpectedOutput, context=context)
+
+
+from ..risk import Financial as FinancialTotalInput
+from ..outputs import ConsequenceFinancialTotalOutput as FinancialTotalOutput
+
+def financial_total(inputs: FinancialTotalInput, *, context: Context | None = None) -> CalculationResult[FinancialTotalOutput]:
+    'Sum non-overlapping financial consequence categories'
+    return calculate('consequence/financial-total', inputs, output_type=FinancialTotalOutput, context=context)
+
+
+from ..consequences import FinalArea as FinalAreaInput
+from ..outputs import ConsequenceFinalAreaOutput as FinalAreaOutput
+
+def final_area(inputs: FinalAreaInput, *, context: Context | None = None) -> CalculationResult[FinalAreaOutput]:
+    'Final Level 1 consequence areas'
+    return calculate('consequence/final-area', inputs, output_type=FinalAreaOutput, context=context)
+
+
+from ..consequences import Weighted as HoleWeightedInput
+from ..outputs import ConsequenceHoleWeightedOutput as HoleWeightedOutput
+
+def hole_weighted(inputs: HoleWeightedInput, *, context: Context | None = None) -> CalculationResult[HoleWeightedOutput]:
+    'Generic-frequency weighted four-hole consequence'
+    return calculate('consequence/hole-weighted', inputs, output_type=HoleWeightedOutput, context=context)
+
+
+from ..physical_explosion import NfntCase as Level2NfntCaseInput
+from ..outputs import ConsequenceLevel2NfntCaseOutput as Level2NfntCaseOutput
+
+def level2_nfnt_case(inputs: Level2NfntCaseInput, *, context: Context | None = None) -> CalculationResult[Level2NfntCaseOutput]:
+    'Level2 NFNT maximum areas and non-ignition weighting'
+    return calculate('consequence/level2-nfnt-case', inputs, output_type=Level2NfntCaseOutput, context=context)
+
+
+from ..physical_explosion import NfntSummary as Level2NfntSummaryInput
+from ..outputs import ConsequenceLevel2NfntSummaryOutput as Level2NfntSummaryOutput
+
+def level2_nfnt_summary(inputs: Level2NfntSummaryInput, *, context: Context | None = None) -> CalculationResult[Level2NfntSummaryOutput]:
+    'Four-hole Level2 NFNT GFF-weighted final areas'
+    return calculate('consequence/level2-nfnt-summary', inputs, output_type=Level2NfntSummaryOutput, context=context)
+
+
+from ..toxic_level2 import MixtureLimit as ToxicMixtureLimitInput
+from ..outputs import ConsequenceToxicMixtureLimitOutput as ToxicMixtureLimitOutput
+
+def toxic_mixture_limit(inputs: ToxicMixtureLimitInput, *, context: Context | None = None) -> CalculationResult[ToxicMixtureLimitOutput]:
+    'Homogeneous mixture cloud toxic concentration criterion'
+    return calculate('consequence/toxic-mixture-limit', inputs, output_type=ToxicMixtureLimitOutput, context=context)
+
+
+from ..toxic_level2 import ToxicCase as Level2ToxicCaseInput
+from ..outputs import ConsequenceLevel2ToxicCaseOutput as Level2ToxicCaseOutput
+
+def level2_toxic_case(inputs: Level2ToxicCaseInput, *, context: Context | None = None) -> CalculationResult[Level2ToxicCaseOutput]:
+    'Selected toxic cloud footprints to conditional toxic consequence'
+    return calculate('consequence/level2-toxic-case', inputs, output_type=Level2ToxicCaseOutput, context=context)
+
+
+from ..toxic_level2 import ToxicSummary as Level2ToxicSummaryInput
+from ..outputs import ConsequenceLevel2ToxicSummaryOutput as Level2ToxicSummaryOutput
+
+def level2_toxic_summary(inputs: Level2ToxicSummaryInput, *, context: Context | None = None) -> CalculationResult[Level2ToxicSummaryOutput]:
+    'Four-hole GFF-weighted Level2 toxic consequence'
+    return calculate('consequence/level2-toxic-summary', inputs, output_type=Level2ToxicSummaryOutput, context=context)
+
+
+from ..toxic_criteria import ToxicCriterion as SelectToxicCriterionInput
+from ..outputs import ConsequenceSelectToxicCriterionOutput as SelectToxicCriterionOutput
+
+def select_toxic_criterion(inputs: SelectToxicCriterionInput, *, context: Context | None = None) -> CalculationResult[SelectToxicCriterionOutput]:
+    'Select duration-matched toxic criterion by API581 priority'
+    return calculate('consequence/select-toxic-criterion', inputs, output_type=SelectToxicCriterionOutput, context=context)
+
+
+__all__ = ['CriterionCandidateInput', 'HoleValueInput', 'NfntFrequencyCaseInput', 'OutcomeInput', 'ToxicCloudAreaInput', 'ToxicFrequencyCaseInput', 'power_law_area', 'PowerLawAreaInput', 'PowerLawAreaOutput', 'expected', 'ExpectedInput', 'ExpectedOutput', 'financial_total', 'FinancialTotalInput', 'FinancialTotalOutput', 'final_area', 'FinalAreaInput', 'FinalAreaOutput', 'hole_weighted', 'HoleWeightedInput', 'HoleWeightedOutput', 'level2_nfnt_case', 'Level2NfntCaseInput', 'Level2NfntCaseOutput', 'level2_nfnt_summary', 'Level2NfntSummaryInput', 'Level2NfntSummaryOutput', 'toxic_mixture_limit', 'ToxicMixtureLimitInput', 'ToxicMixtureLimitOutput', 'level2_toxic_case', 'Level2ToxicCaseInput', 'Level2ToxicCaseOutput', 'level2_toxic_summary', 'Level2ToxicSummaryInput', 'Level2ToxicSummaryOutput', 'select_toxic_criterion', 'SelectToxicCriterionInput', 'SelectToxicCriterionOutput']