api581-engine 0.1.4__py3-none-any.whl

api581/temper.py

@@ -0,0 +1,105 @@
+"""Part 2 §21 low-alloy temper embrittlement; unresolved correlations stay explicit."""
+from typing import Annotated, Literal
+from pydantic import Field, model_validator
+from .core import Model, NonNegative, Positive, calculation, ensure
+from .brittle import BrittleReference, BrittleBase, Interpolation, brittle_reference, brittle_base
+
+WeightPercent = Annotated[float, Field(ge=0, le=100, strict=True, allow_inf_nan=False)]
+
+
+class JComposition(Model):
+    silicon_weight_percent: WeightPercent
+    manganese_weight_percent: WeightPercent
+    phosphorus_weight_percent: WeightPercent
+    tin_weight_percent: WeightPercent
+
+    @model_validator(mode="after")
+    def total(self):
+        if sum((self.silicon_weight_percent,self.manganese_weight_percent,
+                self.phosphorus_weight_percent,self.tin_weight_percent)) > 100:
+            raise ValueError("Composition weight percentages exceed 100")
+        return self
+
+
+@calculation("damage/temper-j-factor", "Temper embrittlement composition J factor", JComposition,
+             ["Part 2 §21.2; eq (2.87); PDF p273"],
+             limitations=["Inputs are numerical weight percentages, not 0-1 fractions. Correlation for 2.25Cr-1Mo/3Cr-1Mo susceptibility; factor alone does not determine DF. Printed eq (2.90) has an unresolved 10^4 exponent; automatic J-to-temperature-shift conversion is not enabled."])
+def temper_j_factor(x):
+    return {"j_factor": (x.silicon_weight_percent+x.manganese_weight_percent)*
+            (x.phosphorus_weight_percent+x.tin_weight_percent)*1e4}
+
+
+class XbarComposition(Model):
+    phosphorus_weight_percent: WeightPercent
+    antimony_weight_percent: WeightPercent
+    tin_weight_percent: WeightPercent
+    arsenic_weight_percent: WeightPercent
+
+    @model_validator(mode="after")
+    def total(self):
+        if sum((self.phosphorus_weight_percent,self.antimony_weight_percent,
+                self.tin_weight_percent,self.arsenic_weight_percent)) > 100:
+            raise ValueError("Composition weight percentages exceed 100")
+        return self
+
+
+@calculation("damage/temper-xbar", "Temper embrittlement composition X-bar factor", XbarComposition,
+             ["Part 2 §21.2; eq (2.88); PDF p273"],
+             limitations=["Inputs are numerical weight percentages, not fractions or ppm. Owner qualifies applicability to 1.25Cr-0.5Mo/1Cr-0.5Mo alloys."])
+def temper_xbar(x):
+    return {"xbar_factor": (10*x.phosphorus_weight_percent+5*x.antimony_weight_percent+
+            4*x.tin_weight_percent+x.arsenic_weight_percent)*100}
+
+
+class XbarShift(Model):
+    xbar_factor: NonNegative
+
+
+@calculation("damage/temper-xbar-shift", "X-bar long-term FATT temperature shift", XbarShift,
+             ["Part 2 §21.6.3 STEP 4(3); eq (2.91); §21.7; PDF pp274-275"],
+             limitations=["Equation output is a Celsius temperature difference, hence numerically K, per §21.7. Negative predicted shifts are rejected; no implicit zero clipping. Long-term empirical relation; material and exposure applicability require owner qualification."])
+def temper_xbar_shift(x):
+    shift = -87.335+11.437*x.xbar_factor-.1472*x.xbar_factor**2
+    ensure(shift >= 0, "X-bar correlation gives a negative embrittlement shift; supply qualified measured/engineering shift", "outside_correlation_domain")
+    return {"delta_fatt_k": shift}
+
+
+class GenerationShift(Model):
+    fabrication_year: int = Field(strict=True, ge=1965)
+    source_basis: Literal["printed_C", "printed_F_difference_converted"]
+
+
+@calculation("damage/temper-generation-shift", "Fabrication-era conservative FATT shift", GenerationShift,
+             ["Part 2 §21.6.3 STEP 4(4); PDF p274"],
+             limitations=["Printed paired C/F shifts are inconsistent as temperature differences. Caller must choose printed_C or printed_F_difference_converted explicitly; this choice is preserved in output. The text says after 1988 and the preceding band ends 1987: year 1988 is rejected. No pre-1965 rule."])
+def temper_generation_shift(x):
+    ensure(x.fabrication_year != 1988, "Year 1988 is not uniquely assigned by printed generation bands", "unresolved_applicability")
+    if x.fabrication_year >= 1989: generation, c, f = 4,66,150
+    elif x.fabrication_year >= 1981: generation, c, f = 3,121,250
+    elif x.fabrication_year >= 1973: generation, c, f = 2,149,300
+    else: generation, c, f = 1,177,350
+    return {"generation": generation, "delta_fatt_k": c if x.source_basis == "printed_C" else f*5/9,
+            "source_basis": x.source_basis}
+
+
+class TemperDamage(Model):
+    reference: BrittleReference
+    minimum_pressurization_temperature_k: Positive
+    delta_fatt_k: NonNegative
+    component_thickness_m: Positive
+    post_weld_heat_treated: bool = Field(strict=True)
+    interpolation: Interpolation
+
+
+@calculation("damage/temper-embrittlement", "Low-alloy temper embrittlement damage factor", TemperDamage,
+             ["Part 2 §21.6.3 STEP 3-6; Tables 20.3,20.4M,20.5M; PDF pp274-275"],
+             limitations=["Owner qualifies susceptible alloy/exposure and minimum pressurization temperature. Uses supplied measured/qualified delta-FATT; no automatic ambiguous SCE or J-factor shift. No service-experience reduction or inspection credit is specified in §21 STEP 6, and neither is applied. US reference table converted to SI, printed SI base-DF grids; no extrapolation."])
+def temper_damage(x):
+    ensure(x.reference.material_group == "low_alloy_steel", "Temper model requires low-alloy-steel reference table")
+    reference = brittle_reference(x.reference)
+    shifted = reference["reference_temperature_k"]+x.delta_fatt_k
+    delta = x.minimum_pressurization_temperature_k-shifted
+    base = brittle_base(BrittleBase(component_thickness_m=x.component_thickness_m,
+        cet_minus_reference_k=delta,post_weld_heat_treated=x.post_weld_heat_treated,interpolation=x.interpolation))
+    return {**reference,"shifted_reference_temperature_k":shifted,"minimum_minus_shifted_reference_k":delta,
+            "delta_fatt_k":x.delta_fatt_k,"damage_factor":base["base_damage_factor"],"table":base["table"]}

api581/thinning.py

@@ -0,0 +1,172 @@
+"""2016 Part 2 §4.5.7 thinning calculations; no cladding/AST auto-selection."""
+import math
+from typing import Literal
+from pydantic import Field, model_validator
+from .core import Model, Positive, NonNegative, Fraction, calculation
+
+PRIORS = {"low": (.5, .3, .2), "medium": (.7, .2, .1), "high": (.8, .15, .05)}
+LIKELIHOODS = {"a": (.9, .09, .01), "b": (.7, .2, .1), "c": (.5, .3, .2), "d": (.4, .33, .27)}
+
+
+class WallLoss(Model):
+    starting_thickness_m: Positive
+    corrosion_rate_m_year: NonNegative
+    elapsed_years: NonNegative
+
+
+@calculation("damage/thinning-wall-loss", "Unclad fractional wall loss", WallLoss,
+             ["Part 2 eq (2.13)"], limitations=["No cladding/weld overlay; not AST-bottom equation (2.12)."])
+def wall_loss(x):
+    return {"wall_loss_fraction": x.corrosion_rate_m_year * x.elapsed_years / x.starting_thickness_m}
+
+
+class FlowStress(Model):
+    yield_strength_pa: Positive
+    tensile_strength_pa: Positive
+    weld_efficiency: Fraction = Field(gt=0)
+
+
+@calculation("damage/flow-stress", "Thinning flow stress", FlowStress,
+             ["Part 2 eq (2.16)"])
+def flow_stress(x):
+    return {"flow_stress_pa": (x.yield_strength_pa + x.tensile_strength_pa) / 2 * x.weld_efficiency * 1.1}
+
+
+class StrengthRatio(Model):
+    differential_pressure_pa: NonNegative
+    diameter_m: Positive
+    flow_stress_pa: Positive
+    starting_thickness_m: Positive
+    shape: Literal["cylinder", "sphere", "head"]
+
+
+@calculation("damage/thinning-strength-ratio", "Internal-pressure thinning strength ratio", StrengthRatio,
+             ["Part 2 eq (2.18); PDF p154"],
+             limitations=["Internal hoop pressure only; not suitable when external pressure or structural loads govern."])
+def strength_ratio(x):
+    alpha = {"cylinder": 2, "sphere": 4, "head": 1.13}[x.shape]
+    return {"strength_ratio": x.differential_pressure_pa * x.diameter_m / (alpha * x.flow_stress_pa * x.starting_thickness_m)}
+
+
+class PriorSelection(Model):
+    confidence: Literal['low','medium','high'] | None = None
+    custom_prior_probabilities: list[Fraction] | None = Field(default=None,min_length=3,max_length=3)
+    custom_prior_basis: str | None = Field(default=None,min_length=1)
+
+    @model_validator(mode='after')
+    def qualified_prior_choice(self):
+        custom=self.custom_prior_probabilities is not None
+        if (self.confidence is not None)==custom:
+            raise ValueError('Select exactly one confidence table row or custom prior probabilities')
+        if custom:
+            if self.custom_prior_basis is None or not self.custom_prior_basis.strip():
+                raise ValueError('Custom prior probabilities require an experience/measurement qualification basis')
+            if not math.isclose(math.fsum(self.custom_prior_probabilities),1.,rel_tol=0.,abs_tol=1e-9):
+                raise ValueError('Custom prior probabilities must sum to1')
+        elif self.custom_prior_basis is not None:
+            raise ValueError('Custom prior basis is unused with a confidence table row')
+        return self
+
+
+@calculation('damage/thinning-prior-selection','Table4.5 or qualified customized thinning damage-state prior',PriorSelection,
+    ['Part2 §4.5.3; Table4.5; PDF pp150-151,163'],limitations=[
+        'Exactly one low/medium/high table row or three owner-qualified prior probabilities for damage states1/2/3 (rate factors1/2/4). Source permits customization from actual experience and confidence in thickness measurements; no automatic calibration or general-to-local applicability inference. Custom sum tolerance1e-9 removes only rounding by normalization. A zero prior cannot be revived by subsequent positive-likelihood inspections; no probability floor is invented.'])
+def prior_selection(x):
+    values=list(PRIORS[x.confidence]) if x.custom_prior_probabilities is None else list(x.custom_prior_probabilities)
+    total=math.fsum(values)
+    return {'prior_probabilities':[p/total for p in values],
+        'prior_source':'table4_5' if x.custom_prior_probabilities is None else 'qualified_custom',
+        'confidence':x.confidence,'zero_prior_state_indices':[i+1 for i,p in enumerate(values) if p==0.]}
+
+
+class Posterior(PriorSelection):
+    inspections_a: int = Field(default=0, ge=0, le=100000)
+    inspections_b: int = Field(default=0, ge=0, le=100000)
+    inspections_c: int = Field(default=0, ge=0, le=100000)
+    inspections_d: int = Field(default=0, ge=0, le=100000)
+
+
+@calculation("damage/thinning-posterior", "Bayesian thinning damage-state probabilities", Posterior,
+             ["Part 2 eqs (2.19)-(2.20), Tables 4.5-4.6; PDF pp154,163"],
+             limitations=["Counts must include only inspections eligible in the assessed period; no equivalent-count conversion. Prior is exactly one confidence table row or qualified customized three-state probabilities per section4.5.3. Zero custom prior remains zero; no floor or automatic calibration."])
+def posterior(x):
+    prior=prior_selection(PriorSelection(**x.model_dump(include=set(PriorSelection.model_fields))))['prior_probabilities']
+    logs = [math.log(p) if p>0 else -math.inf for p in prior]
+    for grade in "abcd":
+        for i in range(3):
+            logs[i] += getattr(x, "inspections_" + grade) * math.log(LIKELIHOODS[grade][i])
+    offset = max(logs)
+    weights = [math.exp(v - offset) for v in logs]
+    total = math.fsum(weights)
+    return {"posterior_probabilities": [v / total for v in weights]}
+
+
+class ThinningBase(Model):
+    wall_loss_fraction: NonNegative
+    strength_ratio: NonNegative
+    posterior: list[Fraction] = Field(min_length=3, max_length=3)
+    cov_wall_loss: Positive = .2
+    cov_strength: Positive = .2
+    cov_pressure: Positive = .05
+
+
+@calculation("damage/thinning-base", "Thinning reliability indices and base damage factor", ThinningBase,
+             ["Part 2 eqs (2.21)-(2.22); PDF p155"], limitations=["Excludes AST bottoms; final adjustment factors applied separately."])
+def thinning_base(x):
+    from .core import ensure
+    ensure(math.isclose(math.fsum(x.posterior), 1, abs_tol=1e-9), "Posterior probabilities must sum to 1")
+    betas = []
+    failures = []
+    for scale in (1, 2, 4):
+        loss = scale * x.wall_loss_fraction
+        variance = loss ** 2 * x.cov_wall_loss ** 2 + (1 - loss) ** 2 * x.cov_strength ** 2 + x.strength_ratio ** 2 * x.cov_pressure ** 2
+        beta = (1 - loss - x.strength_ratio) / math.sqrt(variance)
+        betas.append(beta)
+        failures.append(.5 * math.erfc(beta / math.sqrt(2)))
+    probability = math.fsum(p * f for p, f in zip(x.posterior, failures))
+    return {"reliability_indices": betas, "damage_state_failure_probabilities": failures,
+            "weighted_failure_probability": probability, "base_damage_factor": probability / 1.56e-4}
+
+
+class ThinningAdjustment(Model):
+    base_damage_factor: NonNegative
+    injection_point_factor: Positive
+    deadleg_factor: Positive
+    welded_construction_factor: Positive
+    maintenance_factor: Positive
+    settlement_factor: Positive
+    online_monitoring_factor: Positive
+
+
+@calculation("damage/thinning-adjust", "Apply thinning damage factor adjustments", ThinningAdjustment,
+             ["Part 2 eq (2.23); PDF pp155-156"], limitations=["Caller supplies applicable factors; does not determine AST eligibility or monitoring category."])
+def thinning_adjust(x):
+    value = x.base_damage_factor * x.injection_point_factor * x.deadleg_factor * x.welded_construction_factor * x.maintenance_factor * x.settlement_factor / x.online_monitoring_factor
+    return {"thinning_damage_factor": max(value, .1)}
+
+
+class UncladThinning(Model):
+    wall: WallLoss
+    strength: StrengthRatio
+    inspections: Posterior
+    injection_point_factor: Positive
+    deadleg_factor: Positive
+    online_monitoring_factor: Positive
+
+
+@calculation("damage/thinning-unclad", "Compose unclad non-AST thinning damage calculation", UncladThinning,
+             ["Part 2 §4.5.7 eqs (2.13), (2.18)-(2.23)"],
+             limitations=["Non-AST, unclad, internal-pressure-governed components only. Flow stress and corrosion rate are caller-supplied. Automatic corrosion mechanism/monitoring selection is not included."])
+def unclad(x):
+    from .core import ensure
+    ensure(x.wall.starting_thickness_m == x.strength.starting_thickness_m, "Wall and strength thickness must match")
+    loss = wall_loss(x.wall)
+    sr = strength_ratio(x.strength)
+    post = posterior(x.inspections)
+    base = thinning_base(ThinningBase(wall_loss_fraction=loss["wall_loss_fraction"], strength_ratio=sr["strength_ratio"],
+                                     posterior=post["posterior_probabilities"]))
+    final = thinning_adjust(ThinningAdjustment(base_damage_factor=base["base_damage_factor"],
+                            injection_point_factor=x.injection_point_factor, deadleg_factor=x.deadleg_factor,
+                            online_monitoring_factor=x.online_monitoring_factor, welded_construction_factor=1,
+                            maintenance_factor=1, settlement_factor=1))
+    return {**loss, **sr, **post, **base, **final}

api581/thinning_conditions.py

@@ -0,0 +1,212 @@
+"""2016 thinning monitoring and localized-piping adjustment conditions."""
+from typing import Literal
+from pydantic import Field
+from .core import Model, NonNegative, Positive, calculation, ensure, finite_tree
+from .thinning import WallLoss, Posterior, UncladThinning, unclad
+from .clad_thinning import CladWall, PressureStrength, CodeStrength, CladThinning, clad_thinning, UncladDesignThinning, unclad_design
+
+Row = Literal["hydrochloric_acid","high_temperature_sulfidic_naphthenic","high_temperature_h2s_h2",
+    "sulfuric_low_velocity","sulfuric_high_velocity","hydrofluoric_acid","sour_water_low_velocity",
+    "sour_water_high_velocity","amine_low_velocity","amine_high_velocity","other"]
+Method = Literal["key_process_variables","electrical_resistance_probes","corrosion_coupons"]
+_METHODS = Method.__args__
+_TABLE = dict(zip(Row.__args__,[(10.,10.,2.),(10.,10.,2.),(1.,10.,1.),(20.,10.,2.),(10.,10.,1.),
+    (10.,1.,1.),(20.,10.,2.),(10.,2.,2.),(20.,10.,2.),(10.,10.,1.),(1.,1.,1.)]))
+_JOINT_ROWS = ("hydrochloric_acid","sulfuric_high_velocity")
+
+
+class MonitoringRow(Model):
+    mechanism: Literal["hydrochloric_acid","high_temperature_sulfidic_naphthenic","high_temperature_h2s_h2",
+        "sulfuric_acid","hydrofluoric_acid","sour_water","amine","other"]
+    velocity_m_s: NonNegative | None = None
+    sulfuric_material_group: Literal["carbon_steel","stainless_steel","higher_alloy"] | None = None
+    amine_velocity_regime: Literal["low","high"] | None = None
+    amine_regime_basis: str | None = None
+
+
+@calculation("damage/thinning-monitoring-row", "Select thinning online-monitoring table row", MonitoringRow,
+    ["Part2 Table4.8; PDF p164"],limitations=[
+        "Sulfuric acid low/high thresholds3/5/7ft/s for CS/SS/higher alloys, sour water20ft/s; public m/s with exact.3048 conversion. Threshold equality is low. Amine low/high numeric threshold is not supplied by this table: owner regime and basis required. Mechanism applicability and actual material classification are external qualifications. Printed sulfuric-acid label appends H2S/H2; this API follows named sulfuric-acid row, preserves issue in documentation and does not assert official erratum."])
+def monitoring_row(x):
+    velocity_case = x.mechanism in ("sulfuric_acid","sour_water")
+    ensure((x.velocity_m_s is not None) == velocity_case,"Velocity required only for sulfuric acid or sour water table classification")
+    ensure((x.sulfuric_material_group is not None) == (x.mechanism == "sulfuric_acid"),"Sulfuric material group applies only to sulfuric-acid row")
+    if x.mechanism == "amine":
+        ensure(x.amine_velocity_regime is not None and x.amine_regime_basis is not None and bool(x.amine_regime_basis.strip()),"Amine regime requires owner qualification; no numeric threshold inferred")
+        row, threshold = "amine_"+x.amine_velocity_regime+"_velocity", None
+    else:
+        ensure(x.amine_velocity_regime is None and x.amine_regime_basis is None,"Amine regime fields apply only to amine")
+        if velocity_case:
+            threshold = (dict(carbon_steel=3.,stainless_steel=5.,higher_alloy=7.)[x.sulfuric_material_group] if x.mechanism == "sulfuric_acid" else 20.)*.3048
+            row = ("sulfuric" if x.mechanism == "sulfuric_acid" else "sour_water")+("_low_velocity" if x.velocity_m_s <= threshold else "_high_velocity")
+        else:
+            row, threshold = x.mechanism, None
+    return {"monitoring_row":row,"velocity_threshold_m_s":threshold}
+
+
+class MonitoringCell(Model):
+    monitoring_row: Row
+    monitoring_method: Method
+    key_variables_with_probes: bool = False
+
+
+@calculation("damage/thinning-monitoring-table-factor", "Thinning online-monitoring table cell and explicit joint exception", MonitoringCell,
+    ["Part2 Table4.8; PDF p164"],limitations=[
+        "Table row factors in column order key variables/ER probes/coupons. HCl and high-velocity sulfuric key-variable factor rises10 to20 only in conjunction with probes. This independent cell lookup does not establish a qualified organized monitoring plan; use thinning-online-monitoring-factor for credit gate. Other methods require specialist judgment, not guessed table equivalence."])
+def monitoring_cell(x):
+    if x.key_variables_with_probes:
+        ensure(x.monitoring_row in _JOINT_ROWS and x.monitoring_method == "key_process_variables","Joint20 exception applies only to named key-variable cells")
+        value = 20.
+    else:
+        value = _TABLE[x.monitoring_row][_METHODS.index(x.monitoring_method)]
+    return {"table_monitoring_factor":value}
+
+
+class OnlineMonitoring(Model):
+    row: MonitoringRow
+    methods: list[Method] = Field(max_length=3)
+    organized_monitoring_plan: bool
+    qualification_basis: str | None = None
+    key_variables_probe_conjunction_confirmed: bool = False
+    experience_factor: Positive | None = None
+    experience_factor_basis: str | None = None
+
+
+@calculation("damage/thinning-online-monitoring-factor", "Qualified thinning monitoring credit without stacking", OnlineMonitoring,
+    ["Part2 §4.5.7 STEP15(1),Table4.8 notes1-3; PDF pp155,164"],limitations=[
+        "No organized plan means applied factor1 regardless of installed methods. Qualified plan must recognize mechanism, appropriate variables and specialist intervals. Choose maximum applicable method factor, never sum/product. Joint20 needs both key variables and ER probes plus confirmed conjunction. Table estimates may be replaced by owner-experience positive factor with basis under note1; replacement is entire applied factor, not a stacked bonus. No methods and no override gives1. Other monitoring methods require qualified experience basis; no automatic sensor-data efficacy classification."])
+def online_monitoring(x):
+    selected = monitoring_row(x.row)
+    row = selected["monitoring_row"]
+    ensure(len(set(x.methods)) == len(x.methods),"Monitoring methods must be unique")
+    override = x.experience_factor is not None
+    ensure(override == (x.experience_factor_basis is not None),"Experience factor and basis must be provided together")
+    if override:
+        ensure(bool(x.experience_factor_basis.strip()),"Experience factor basis must not be blank")
+    if x.key_variables_probe_conjunction_confirmed:
+        ensure(x.organized_monitoring_plan and row in _JOINT_ROWS and {"key_process_variables","electrical_resistance_probes"}.issubset(x.methods),"Joint monitoring exception requires qualified conjunction of both methods in applicable row")
+    candidates = {m:monitoring_cell(MonitoringCell(monitoring_row=row,monitoring_method=m,
+        key_variables_with_probes=x.key_variables_probe_conjunction_confirmed and m == "key_process_variables"))["table_monitoring_factor"] for m in x.methods}
+    if not x.organized_monitoring_plan:
+        ensure(not override and x.qualification_basis is None,"Unqualified plan cannot claim experience credit or qualification basis")
+        factor, reason = 1., "no_organized_plan"
+    elif x.methods or override:
+        ensure(x.qualification_basis is not None and bool(x.qualification_basis.strip()),"Monitoring credit requires qualified organized-plan basis")
+        factor, reason = (x.experience_factor,"qualified_experience_replacement") if override else (max(candidates.values()),"maximum_table_method")
+    else:
+        factor, reason = 1., "no_monitoring_methods"
+    return {**selected,"online_monitoring_factor":factor,"candidate_method_factors":candidates,
+        "monitoring_credit_basis":reason,"joint_exception_applied":x.key_variables_probe_conjunction_confirmed and not override}
+
+
+class InjectionPoint(Model):
+    component_scope: Literal["piping","non_piping"]
+    injection_or_mix_point_present: bool
+    highly_effective_targeted_inspection: bool
+    inspection_basis: str | None = None
+
+
+class Deadleg(Model):
+    component_scope: Literal["piping","non_piping"]
+    deadleg_present: bool
+    highly_effective_targeted_inspection: bool
+    inspection_basis: str | None = None
+
+
+def _piping_factor(scope,present,inspected,basis):
+    if scope == "non_piping":
+        ensure(not present and not inspected and basis is None,"Piping feature and inspection credit cannot be claimed for non-piping component")
+    if inspected:
+        ensure(present and basis is not None and bool(basis.strip()),"Highly effective targeted inspection requires feature and qualification basis")
+    else:
+        ensure(basis is None,"Inspection basis cannot accompany unclaimed inspection")
+    return 3. if present and not inspected else 1.
+
+
+@calculation("damage/thinning-injection-point-factor", "Thinning injection or corrosive mix point adjustment", InjectionPoint,
+    ["Part2 §4.5.7 STEP15(2); PDF p156"],limitations=[
+        "Piping with injection/mix point factor3, reduced1 only by highly effective targeted inspection per source API570 reference. Owner classifies actual mix corrosion: flashing liquid/vapor mixing, water-bearing streams or mixed temperature below combined dew point. Generic inspection does not earn automatic credit. Non-piping factor1."])
+def injection_point(x):
+    return {"injection_point_factor":_piping_factor(x.component_scope,x.injection_or_mix_point_present,x.highly_effective_targeted_inspection,x.inspection_basis)}
+
+
+@calculation("damage/thinning-deadleg-factor", "Thinning intermittent-service or stagnant deadleg adjustment", Deadleg,
+    ["Part2 §4.5.7 STEP15(3); PDF p156"],limitations=[
+        "Piping deadleg factor3, reduced1 only by highly effective inspection specifically addressing localized deadleg corrosion. Owner classifies intermittent/no-significant-flow service; no automatic velocity threshold. Non-piping factor1."])
+def deadleg(x):
+    return {"deadleg_factor":_piping_factor(x.component_scope,x.deadleg_present,x.highly_effective_targeted_inspection,x.inspection_basis)}
+
+
+class ThinningConditions(Model):
+    monitoring: OnlineMonitoring
+    injection: InjectionPoint
+    deadleg: Deadleg
+
+
+def condition_factors(x):
+    ensure(x.injection.component_scope == x.deadleg.component_scope,"Injection and deadleg component scopes must agree")
+    return {**online_monitoring(x.monitoring),**injection_point(x.injection),**deadleg(x.deadleg)}
+
+
+class ConditionalAdjustment(Model):
+    assessment_scope: Literal["non_ast"]
+    base_damage_factor: NonNegative
+    conditions: ThinningConditions
+
+
+@calculation("damage/thinning-conditional-adjustment", "Apply qualified non-AST thinning adjustment conditions", ConditionalAdjustment,
+    ["Part2 §4.5.7 STEP15,eq(2.23),Table4.8; PDF pp155-156,164"],origin="api581_composition",limitations=[
+        "Non-AST conditions only: AST construction, maintenance and settlement factors1. FinalDF=max(baseDF*injection*deadleg/monitoring,.1). Monitoring uses maximum qualified method or documented experience replacement; no duplicate monitoring factors. No automatic corrosion/inspection applicability screening."])
+def conditional_adjustment(x):
+    factors = condition_factors(x.conditions)
+    value = x.base_damage_factor*factors["injection_point_factor"]*factors["deadleg_factor"]/factors["online_monitoring_factor"]
+    finite_tree(value)
+    return {**factors,"base_damage_factor":x.base_damage_factor,"thinning_damage_factor":max(value,.1)}
+
+
+class QualifiedUnclad(Model):
+    assessment_scope: Literal["non_ast_unclad"]
+    qualification_basis: str = Field(min_length=1)
+    wall: WallLoss
+    strength: PressureStrength | CodeStrength = Field(discriminator="method")
+    inspections: Posterior
+    conditions: ThinningConditions
+
+
+@calculation("damage/thinning-unclad-qualified", "Unclad non-AST thinning with condition-derived adjustment factors", QualifiedUnclad,
+    ["Part2 §4.5.7,eqs(2.13),(2.17)-(2.23),Table4.8; PDF pp153-156,164"],origin="api581_composition",limitations=[
+        "Qualified non-AST unclad component; shared wall/strength baseline required. Governing strength method explicit; code minima and load applicability remain supplied. Conditions derive piping/monitoring adjustments rather than accepting duplicate numeric factors. Table row classification is not corrosion-mechanism applicability screening or inspection validation. No all-mechanism DF or AST corrections."])
+def qualified_unclad(x):
+    ensure(bool(x.qualification_basis.strip()),"Applicability basis must not be blank")
+    factors = condition_factors(x.conditions)
+    args = dict(wall=x.wall,inspections=x.inspections,injection_point_factor=factors["injection_point_factor"],
+        deadleg_factor=factors["deadleg_factor"],online_monitoring_factor=factors["online_monitoring_factor"])
+    if x.strength.method == "design_thickness_eq2_17":
+        from .clad_thinning import DesignStrengthRatio
+        result = unclad_design(UncladDesignThinning(**args,assessment_scope="non_ast_unclad_design_thickness_governed",
+            qualification_basis=x.qualification_basis,strength=DesignStrengthRatio(**x.strength.model_dump(exclude={"method"}))))
+    else:
+        from .thinning import StrengthRatio
+        result = unclad(UncladThinning(**args,strength=StrengthRatio(**x.strength.model_dump(exclude={"method"}))))
+    return {k:v for k,v in {**result,**factors,"strength_method":x.strength.method}.items() if k not in ("governing_minimum_thickness_m","governing_thickness_source")}
+
+
+class QualifiedClad(Model):
+    assessment_scope: Literal["non_ast_pressure_vessel_sequential_cladding"]
+    qualification_basis: str = Field(min_length=1)
+    wall: CladWall
+    strength: PressureStrength | CodeStrength = Field(discriminator="method")
+    inspections: Posterior
+    conditions: ThinningConditions
+
+
+@calculation("damage/thinning-clad-qualified", "Clad pressure-vessel thinning with condition-derived monitoring adjustment", QualifiedClad,
+    ["Part2 §4.5.7,eqs(2.11),(2.13)-(2.23),Table4.8; PDF pp152-156,164"],origin="api581_composition_with_explicit_zero_rate_extension",limitations=[
+        "Non-AST pressure vessel with sequential-cladding scope, owner-qualified corrosion rates and baseline. Injection/deadleg conditions must both be non-piping. Shared monitoring classification drives one applied factor. Reuses clad zero-rate extension and both strength methods; no coating/lining, simultaneous backside corrosion, code-minimum calculation or all-mechanism DF."])
+def qualified_clad(x):
+    ensure(x.conditions.injection.component_scope == x.conditions.deadleg.component_scope == "non_piping","Clad pressure-vessel composition requires non-piping condition scope")
+    factors = condition_factors(x.conditions)
+    result = clad_thinning(CladThinning(assessment_scope="non_ast_pressure_vessel_sequential_cladding",qualification_basis=x.qualification_basis,
+        wall=x.wall,strength=x.strength,inspections=x.inspections,injection_point_factor=factors["injection_point_factor"],
+        deadleg_factor=factors["deadleg_factor"],online_monitoring_factor=factors["online_monitoring_factor"]))
+    return {**result,**factors}

api581/thinning_history.py

@@ -0,0 +1,118 @@
+"""Date-consistent thickness baseline and period-qualified inspection counts."""
+from datetime import timezone
+from typing import Literal
+from pydantic import AwareDatetime, Field
+from .core import Model, Positive, calculation, ensure
+from .thinning import PriorSelection, Posterior
+from .thinning_selection import ThinningRateSelection, SelectedMechanismThinning, selected_mechanism_thinning
+from .clad_thinning import PressureStrength, CodeStrength
+from .thinning_conditions import ThinningConditions
+
+
+class MeasuredBaseline(Model):
+    inspection_id: str = Field(min_length=1,max_length=100)
+    measured_at: AwareDatetime
+    thickness_m: Positive
+    high_quality_inspection: bool
+    high_confidence_accuracy: bool
+    reset_basis: str = Field(min_length=1)
+
+
+class ThinningPeriod(Model):
+    installed_at: AwareDatetime
+    assessment_at: AwareDatetime
+    baseline_type: Literal['furnished','measured']
+    furnished_thickness_m: Positive | None = None
+    measured_baseline: MeasuredBaseline | None = None
+    days_per_year: Positive
+    period_and_year_basis: str = Field(min_length=1)
+
+
+def _utc(value):
+    return value.astimezone(timezone.utc)
+
+
+@calculation('damage/thinning-assessment-period','Consistent furnished/measured thickness baseline and elapsed period',ThinningPeriod,
+    ['Part2 §4.5.5; PDF p151'],limitations=[
+        'Timezone-aware timestamps normalized to UTC. Furnished thickness starts at installation; selected measured thickness starts at its qualified inspection time, requiring high-quality inspection, high-confidence accuracy and reset basis. Year conversion is explicit caller convention, not an API581-mandated constant. No process-change detection, measurement uncertainty correction, automatic reset selection or thickness reconciliation.'])
+def thinning_period(x):
+    ensure(bool(x.period_and_year_basis.strip()),'Common plan period and year conversion basis required')
+    installed,assessment=_utc(x.installed_at),_utc(x.assessment_at)
+    ensure(installed<=assessment,'Assessment cannot precede installation')
+    if x.baseline_type=='furnished':
+        ensure(x.furnished_thickness_m is not None and x.measured_baseline is None,'Furnished baseline requires only furnished thickness')
+        baseline,thickness,inspection_id=installed,x.furnished_thickness_m,None
+    else:
+        ensure(x.measured_baseline is not None and x.furnished_thickness_m is None,'Measured baseline requires only measured baseline record')
+        measured=x.measured_baseline
+        ensure(measured.high_quality_inspection and measured.high_confidence_accuracy and bool(measured.reset_basis.strip()),
+            'Measured thickness reset requires qualified inspection quality, accuracy and basis')
+        ensure(bool(measured.inspection_id.strip()),'Baseline inspection ID must be nonblank')
+        baseline,thickness,inspection_id=_utc(measured.measured_at),measured.thickness_m,measured.inspection_id
+        ensure(installed<=baseline<=assessment,'Measured baseline must lie between installation and assessment')
+    days=(assessment-baseline).total_seconds()/86400.
+    return dict(baseline_type=x.baseline_type,baseline_at=baseline.isoformat(),assessment_at=assessment.isoformat(),
+        baseline_thickness_m=thickness,baseline_inspection_id=inspection_id,elapsed_days=days,
+        elapsed_years=days/x.days_per_year,days_per_year=x.days_per_year)
+
+
+class ThinningInspectionRecord(Model):
+    inspection_id: str = Field(min_length=1,max_length=100)
+    performed_at: AwareDatetime
+    effectiveness: Literal['a','b','c','d','e']
+    qualified_for_component_mechanism: bool
+    inspection_basis: str = Field(min_length=1)
+
+
+class ThinningInspectionHistory(ThinningPeriod):
+    inspections: list[ThinningInspectionRecord] = Field(max_length=10000)
+    baseline_boundary_policy: Literal['include_baseline_time','exclude_baseline_time']
+
+
+@calculation('damage/thinning-inspection-history','Assessment-period inspection eligibility and direct A-D counts',ThinningInspectionHistory,
+    ['Part2 §§4.5.5-4.5.6; Tables4.6,2.C inspection guidance; PDF pp151-152'],limitations=[
+        'Only performed, qualified inspections in the selected period receive A-D counts; E receives no credit. Before-baseline and after-assessment records remain excluded diagnostics. Exact baseline-time inclusion is explicit owner policy; source does not resolve duplicate use of a baseline-setting inspection. End time is included. Duplicate IDs or a baseline inspection ID with conflicting timestamp fail. No automatic NDE effectiveness grading, equivalent-count conversion, geometry/coverage qualification or credit for planned inspections.'])
+def thinning_inspection_history(x):
+    period=thinning_period(ThinningPeriod(**x.model_dump(include=set(ThinningPeriod.model_fields))))
+    baseline,assessment=_utc(x.installed_at if x.baseline_type=='furnished' else x.measured_baseline.measured_at),_utc(x.assessment_at)
+    ids=[i.inspection_id for i in x.inspections]
+    ensure(len(set(ids))==len(ids) and all(s.strip() for s in ids),'Inspection IDs must be nonblank and unique')
+    counts={grade:0 for grade in 'abcd'}
+    eligible,excluded=[],{}
+    for item in x.inspections:
+        ensure(bool(item.inspection_basis.strip()),'Inspection effectiveness/eligibility basis required')
+        at=_utc(item.performed_at)
+        if item.inspection_id==period['baseline_inspection_id']:
+            ensure(at==baseline,'Baseline inspection ID has conflicting performed time')
+        reason=('before_baseline' if at<baseline else 'after_assessment' if at>assessment else
+            'baseline_boundary' if at==baseline and x.baseline_boundary_policy=='exclude_baseline_time' else
+            'unqualified' if not item.qualified_for_component_mechanism else 'ineffective_e' if item.effectiveness=='e' else None)
+        if reason:
+            excluded[item.inspection_id]=reason
+        else:
+            counts[item.effectiveness]+=1
+            eligible.append(item.inspection_id)
+    return {**period,**{'inspections_'+grade:value for grade,value in counts.items()},
+        'eligible_inspection_ids':sorted(eligible),'excluded_inspection_reasons':excluded,
+        'baseline_boundary_policy':x.baseline_boundary_policy}
+
+
+class HistoryThinningAssessment(Model):
+    history: ThinningInspectionHistory
+    selection: ThinningRateSelection
+    prior: PriorSelection
+    strength: PressureStrength | CodeStrength = Field(discriminator='method')
+    conditions: ThinningConditions
+    qualification_basis: str = Field(min_length=1)
+
+
+@calculation('damage/thinning-history-assessment','Thickness/history/rate selection through period-consistent thinning DF',HistoryThinningAssessment,
+    ['Part2 §§4.5.2-4.5.7; PDF pp150-156'],origin='qualified_thinning_baseline_history_composition',limitations=[
+        'Selected baseline derives both wall thickness and elapsed period; eligible dated inspection records derive counts, with independently selected table/custom prior. No competing manually supplied age/counts. Strength baseline must agree with derived wall baseline. Rate-selection common-period and inspection coverage/type qualifications remain external. Generic other monitoring row only, no borrowed mechanism credits. Non-AST unclad scope; no automatic process-change reset, inspection scheduling, cladding or all-mechanism/asset risk.'])
+def thinning_history_assessment(x):
+    history=thinning_inspection_history(x.history)
+    inspections=Posterior(**x.prior.model_dump(),**{key:history[key] for key in ('inspections_a','inspections_b','inspections_c','inspections_d')})
+    result=selected_mechanism_thinning(SelectedMechanismThinning(selection=x.selection,
+        starting_thickness_m=history['baseline_thickness_m'],elapsed_years=history['elapsed_years'],strength=x.strength,
+        inspections=inspections,conditions=x.conditions,qualification_basis=x.qualification_basis))
+    return {**history,**result}