Dynamic Inspection Frequency Calculation Based on Tower Age and Load

A fixed twelve- or twenty-four-month inspection cadence is a structural and financial liability. It over-inspects a young monopole running at thirty percent of its design load while under-inspecting a fifteen-year-old guyed tower carrying a stacked 5G massive-MIMO and microwave payload at eighty-five percent capacity. This walkthrough builds a small, deterministic Python engine that computes a defensible inspection interval per tower from three signals — chronological age, structural load ratio, and historical defect density — and then clamps that interval up to the strictest contractual floor so it can never silently under-schedule a regulated asset. It is the age-and-load calculation path of the parent Frequency Logic & Threshold Tuning engine: the parent decides how a portfolio’s timing logic is tuned and damped overall, while this page shows the exact arithmetic that turns one tower’s telemetry into one number of months.

Prerequisites & Context #

The engine targets Python 3.10 or newer and uses only the standard library — dataclasses for the asset and result records, datetime for age arithmetic, logging for a structured audit line, and hashlib for the tamper-evident seal. No third-party install is required, so the module below runs immediately.

Three inputs must be in place before a frequency can be trusted. First, a canonical structural load ratio: the tower’s current applied weight over its original design capacity, sourced from the same structural records that drive the wider Intelligent Inspection Scheduling & Technician Routing control plane. Second, a jurisdiction floor — the maximum months a municipality permits between mandatory structural reviews, typically derived from the zoning record that the compliance-side Zoning Rule Engine Design already resolves. Third, a lease-minimum floor, the carrier SLA interval reconciled from fragmented agreements by Lease Taxonomy Standardization. The calculated interval is only ever allowed to be longer than both floors, never shorter — the floors are hard compliance limits, not suggestions.

Step-by-Step Implementation #

Step 1 — Anchor a baseline interval and decay it with age. Start from a base interval (24 months) and apply a linear age penalty. Each year shaves a small fixed fraction off the interval, but the factor is clamped so a very old tower never decays past a floor and collapses to an absurd weekly cadence on age alone:

age_years = (as_of - asset.install_date).days / 365.25
age_factor = max(0.70, 1.0 - (age_years * 0.015))  # capped at a 30% reduction

Step 2 — Compute the structural load ratio and penalize it non-linearly. Below the 0.65 threshold, load contributes no penalty. Above it, fatigue and wind-loading vulnerability accelerate, so the interval contracts on a hyperbolic curve rather than a straight line — a tower at 0.85 is treated as materially more urgent than a linear model would suggest:

load_ratio = asset.current_load_kg / asset.design_capacity_kg
if load_ratio > 0.65:
    load_penalty = 1.0 / (1.0 + ((load_ratio - 0.65) * 2.5))
else:
    load_penalty = 1.0

Step 3 — Fold in historical defect density. A tower with a track record of non-conformances warrants a tighter cadence than a clean one. Each recorded defect multiplies the interval by a decay factor, so defect pressure compounds geometrically rather than being counted linearly:

defect_modifier = 0.92 ** asset.historical_defects
raw_months = 24.0 * age_factor * load_penalty * defect_modifier

Step 4 — Clamp up to the strictest compliance floor. This is the step that keeps automation legal. Take the largest of the calculated interval, the jurisdiction floor, and the lease minimum. Selecting max guarantees the engine can lengthen but never shorten past a regulated limit — if the algorithm wants 4 months but the lease permits 6, the lease wins:

enforced_months = max(raw_months, asset.jurisdiction_floor_months, asset.lease_minimum_months)

Step 5 — Categorize for dispatch and seal the decision. Bucket the enforced interval into a CRITICAL / ELEVATED / STANDARD tier that downstream routing consumes, then hash the canonical inputs and outputs with SHA-256 so a municipal auditor or lease counterparty can later prove the number was not altered after the fact.

Complete Runnable Example #

The module below runs immediately against a realistic asset — site TWR-7731, zoning MUN-4A-RES, a seventeen-year-old tower loaded to 85% of design capacity with three logged defects. The as_of parameter defaults to the current UTC time in production but is pinned here so the output is reproducible. Swap the hard-coded TowerAsset for a feed from your CMDB and the same logic serves an entire portfolio.

import hashlib
import json
import logging
from dataclasses import dataclass, asdict
from datetime import datetime, timezone

logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
logger = logging.getLogger("frequency_engine")


class FrequencyCalculationError(Exception):
    """Base exception for inspection-frequency calculation failures."""


class InvalidLoadRatioError(FrequencyCalculationError):
    """Raised when load parameters violate physical constraints."""


class ComplianceFloorViolationError(FrequencyCalculationError):
    """Raised when jurisdictional or lease floors are invalid."""


@dataclass
class TowerAsset:
    asset_id: str
    zoning_code: str
    install_date: datetime
    design_capacity_kg: float
    current_load_kg: float
    historical_defects: int
    jurisdiction_floor_months: int
    lease_minimum_months: int


@dataclass
class FrequencyResult:
    asset_id: str
    load_ratio: float
    calculated_months: float
    enforced_months: float
    risk_category: str
    audit_hash: str
    timestamp: str


class InspectionFrequencyEngine:
    BASE_INTERVAL_MONTHS = 24.0
    LOAD_THRESHOLD = 0.65
    AGE_DECAY_PER_YEAR = 0.015
    AGE_FACTOR_FLOOR = 0.70
    DEFECT_PENALTY_FACTOR = 0.92

    def calculate(self, asset: TowerAsset, as_of: datetime = None) -> FrequencyResult:
        as_of = as_of or datetime.now(timezone.utc)
        self._validate_asset(asset)

        age_years = (as_of - asset.install_date).days / 365.25
        load_ratio = asset.current_load_kg / asset.design_capacity_kg

        age_factor = max(self.AGE_FACTOR_FLOOR, 1.0 - (age_years * self.AGE_DECAY_PER_YEAR))

        if load_ratio > self.LOAD_THRESHOLD:
            load_penalty = 1.0 / (1.0 + ((load_ratio - self.LOAD_THRESHOLD) * 2.5))
        else:
            load_penalty = 1.0

        defect_modifier = self.DEFECT_PENALTY_FACTOR ** asset.historical_defects

        raw_months = self.BASE_INTERVAL_MONTHS * age_factor * load_penalty * defect_modifier
        raw_months = max(1.0, raw_months)

        enforced_months = max(
            raw_months,
            asset.jurisdiction_floor_months,
            asset.lease_minimum_months,
        )

        if enforced_months <= 6:
            risk_cat = "CRITICAL"
        elif enforced_months <= 12:
            risk_cat = "ELEVATED"
        else:
            risk_cat = "STANDARD"

        audit_hash = self._audit_hash(asset, raw_months, enforced_months)
        logger.info("FREQ | %s | ratio=%.2f | months=%.1f | %s | %s",
                    asset.asset_id, load_ratio, enforced_months, risk_cat, audit_hash[:12])

        return FrequencyResult(
            asset_id=asset.asset_id,
            load_ratio=round(load_ratio, 2),
            calculated_months=round(raw_months, 1),
            enforced_months=round(enforced_months, 1),
            risk_category=risk_cat,
            audit_hash=audit_hash,
            timestamp=as_of.isoformat(),
        )

    def _validate_asset(self, asset: TowerAsset) -> None:
        if asset.design_capacity_kg <= 0:
            raise InvalidLoadRatioError(f"{asset.asset_id}: design capacity must be positive")
        if asset.current_load_kg < 0:
            raise InvalidLoadRatioError(f"{asset.asset_id}: current load cannot be negative")
        if asset.jurisdiction_floor_months < 1 or asset.lease_minimum_months < 1:
            raise ComplianceFloorViolationError(f"{asset.asset_id}: floors must be >= 1 month")

    def _audit_hash(self, asset: TowerAsset, raw: float, enforced: float) -> str:
        payload = json.dumps({
            "asset_id": asset.asset_id,
            "zoning_code": asset.zoning_code,
            "install_date": asset.install_date.isoformat(),
            "design_capacity_kg": asset.design_capacity_kg,
            "current_load_kg": asset.current_load_kg,
            "historical_defects": asset.historical_defects,
            "raw_months": round(raw, 4),
            "enforced_months": round(enforced, 4),
        }, sort_keys=True, separators=(",", ":"))
        return hashlib.sha256(payload.encode("utf-8")).hexdigest()


if __name__ == "__main__":
    engine = InspectionFrequencyEngine()
    asset = TowerAsset(
        asset_id="TWR-7731",
        zoning_code="MUN-4A-RES",
        install_date=datetime(2009, 1, 15, tzinfo=timezone.utc),
        design_capacity_kg=8000.0,
        current_load_kg=6800.0,
        historical_defects=3,
        jurisdiction_floor_months=6,
        lease_minimum_months=4,
    )
    result = engine.calculate(asset, as_of=datetime(2026, 7, 1, tzinfo=timezone.utc))
    print(json.dumps(asdict(result), indent=2, default=str))

Verification & Expected Output #

Running the module prints one structured audit line followed by the serialized result. The seventeen-year-old tower at an 0.85 load ratio calculates to roughly 9.2 months, which sits above both floors, so the enforced interval equals the calculated one and the tower lands in the ELEVATED dispatch tier:

2026-07-01 09:14:02 | INFO | FREQ | TWR-7731 | ratio=0.85 | months=9.2 | ELEVATED | d97923f84400
{
  "asset_id": "TWR-7731",
  "load_ratio": 0.85,
  "calculated_months": 9.2,
  "enforced_months": 9.2,
  "risk_category": "ELEVATED",
  "audit_hash": "d97923f84400e051ef9ace28259fc94beebd26958b6c61ea2328770d58d16065",
  "timestamp": "2026-07-01T00:00:00+00:00"
}

To confirm the compliance clamp is doing its job, raise jurisdiction_floor_months to 12: calculated_months stays 9.2 but enforced_months jumps to 12.0 and the tier drops to STANDARD — proof the floor lengthened the interval and the engine never scheduled below the regulated limit. A failure looks like a raised exception: set design_capacity_kg=0 and the run terminates with InvalidLoadRatioError before any interval is emitted, so a corrupt load record can never produce a silently-wrong cadence. If the audit_hash changes between two runs with identical inputs and the same as_of, your canonical serialization is non-deterministic — check that _audit_hash still passes sort_keys=True.

Gotchas & Edge Cases #

A live datetime.now() makes the hash non-reproducible unless you pin as_of. Because age is computed against the current instant, the same tower recalculated a month later yields a slightly shorter interval and therefore a different raw_months and audit hash. That is correct behavior, but it means you cannot compare hashes across arbitrary run dates. Store the as_of timestamp alongside the hash, and when you need to re-prove a historical decision, replay the engine with that exact timestamp rather than the wall clock.

The load ratio can exceed 1.0 after an unrecorded antenna stack. Carriers add radios faster than structural records are updated, so current_load_kg occasionally reports above design_capacity_kg. The hyperbolic penalty degrades gracefully past 1.0 (it never divides by zero), but a ratio over 1.0 is itself a red flag — a structural over-capacity condition that should trigger an immediate manual review, not merely a compressed cadence. Add an explicit guard that escalates any ratio above 1.0 straight to CRITICAL regardless of the computed months.

Floors expressed in different units silently corrupt the clamp. A jurisdiction floor recorded in days or quarters rather than months will pass straight through the max() and either lock a tower to an absurdly long interval or fail to protect it at all. Normalize every floor to integer months at ingestion and reject anything non-integer with the ComplianceFloorViolationError path before it ever reaches the calculation.

FAQ #

Related #

• Up to the parent topic: Frequency Logic & Threshold Tuning
• A sibling scheduling task: Optimizing technician routes for multi-site maintenance windows
• Downstream dispatch: Technician Assignment Algorithms
• Weather gating: Weather Window Optimization
• Parent architecture: Intelligent Inspection Scheduling & Technician Routing