Connection design review automation in Tekla

The Five Thousand Connections Problem

Picture the scene at the start of any large commercial steelwork package. The structural model has been through three rounds of design-and-detail iteration. The Tekla file is dense: multi-storey cores, long-span transfer levels, braced bays, moment frames, secondary framing, stairs, plant platforms. The connection engineer opens the model summary. Five thousand, two hundred and forty-one connections.

The deadline for the IFC submission to the fabricator is in eleven working days.

The connection design lead has three senior engineers, each carrying two other active packages. In practice, that allocates about six hours of concentrated review time per person — a total of eighteen hours to assess the adequacy and code compliance of 5,241 connection instances. That is twelve seconds per connection if the reviewer does nothing else: no email, no calls, no walking the floor.

Twelve seconds is enough time to open the component dialog, glance at the connection number, and click Next. It is not enough time to check that the bolt grade is compatible with the base material, that the fillet weld sizes meet the minimum required by the thicker joined part, that a moment end plate was not accidentally placed in a braced bay where only pinned behaviour is assumed, or that the bolt footprint respects the minimum edge distances specified in AISC 360-22 Table J3.4.

This is not a hypothetical failure mode. It is the standard practice on most projects above a certain scale. The review exists on paper; the thoroughness does not. The result is field RFIs, costly fabrication changes, and — occasionally — connections that enter construction with non-compliant fastener specifications.

The engineering profession has a name for the approach that prevents this: it is called a review filter. The idea is old, but the implementation in BIM is new. A review filter does not replace engineering judgement. It compresses the population of connections that require engineering judgement from five thousand to, on a typical project, twenty to forty flagged items — the genuine exceptions. The engineer reviews thirty lines instead of five thousand dialogs.

This article explains how to build those filters in Tekla Structures using the Open API, which rules to encode first, where the approach breaks down, and how to integrate the output into the structural review workflow without letting the automation become a false confidence trap.

There is a secondary argument for this approach that goes beyond efficiency. When a connection review is performed by sampling — by a human selectively opening dialogs in a 5,000-item model — the distribution of attention is uneven. Connections that look familiar receive less scrutiny. Connections with unusual framing attract more. The human reviewer is doing pattern recognition, not systematic verification. Systematic verification is what a rule-based filter does. It applies the same logical test to every connection instance without fatigue, without familiarity bias, and without the time pressure that causes a senior engineer to skip the fourth page of bolt group results because the deadline is tomorrow.

The code examples use C# with the Tekla Open API (tested against Tekla Structures 2024 and 2025). The rule definitions are expressed in YAML so they can be version-controlled separately from the automation executable. The exception report format is CSV, which opens directly in any project management tool or review register.

What Connection Review Actually Checks

Before writing a single line of code, it is worth being precise about what a competent connection design review actually verifies. This matters because automation can only encode rules that are explicitly articulated. The more precisely you define the check, the more reliably the filter fires — and the more honestly you can declare what it does not cover.

1. Geometry Correctness

Geometry checking is the layer most engineers associate with BIM QA. It includes: are parts clashing? Do bolt holes align? Is the plate thickness consistent with the shop drawing? These checks are largely handled by Tekla's own clash detection and the fabricator's CNC preparation workflow. They are not the gap this article addresses. Mention them because a reviewer who conflates geometry checking with connection design review is already in trouble.

What geometry checking does not cover: whether the geometry is structurally adequate. A shear tab that fits spatially may still be undersized for the reaction. A correctly placed end plate may be the wrong type for the framing pattern. Geometry correctness is a necessary but nowhere near sufficient condition for connection adequacy.

2. Code Compliance

Code compliance in connection design has two overlapping layers: detailing requirements and strength requirements. Automation handles the detailing layer well. Strength compliance requires force data that the Tekla model may not carry, so the discussion here focuses on detailing rules that can be evaluated from model geometry and component parameters alone.

Under AISC 360-22 (the current edition of the AISC Specification for Structural Steel Buildings), the primary detailing rules for connections are:

• Section J2.2b / Table J2.4 — Minimum fillet weld sizes based on the thickness of the thicker part joined. The table is reproduced below for reference. The critical implementation note: the standard governs based on the thicker part, not the thinner. This is the most commonly automated check and the most commonly misimplemented one.

Source: AISC 360-22 Table J2.4, Section J2.2b. The thicker of the two joined parts governs. If the minimum exceeds the thickness of the thinner part, the minimum reverts to the thickness of the thinner part.

• Section J3.4 / Table J3.4 — Minimum bolt spacing (2-2/3 times the bolt diameter, with 3 diameters preferred) and edge distances (varies with bolt diameter, from 1 in for 5/8 in bolts to 1-3/4 in for 1-1/8 in bolts).

• Section J3.8 — Bolt tension, shear, and combined loading limit states. These require applied force data and are outside detailing-only automation.

Under EN 1993-1-8 (Eurocode 3, Design of Joints), the key detailing clauses are:

• Section 4.3.2.1(1) — Fillet welds may be used where fusion faces form an angle between 60° and 120°. Outside this range the weld must be treated as a partial penetration butt weld.

• Section 4.5.2 — Minimum effective throat thickness for fillet welds: 3 mm absolute minimum regardless of plate thickness. The EC3 approach uses a formula-based resistance check (directional or simplified method) rather than a pure thickness lookup table. The correlation factor β_w from Table 4.1 varies with material grade (0.80 for S235, 0.85 for S275, 0.90 for S355, 1.00 for S420 and S460).

• Section 3.5 / Table 3.3 — Minimum bolt spacing: 2.2d₀ with 3.0d₀ preferred; minimum edge distance 1.2d₀, with 2.0d₀ recommended.

3. Connection Class vs. Framing Pattern

Every connection in a steel frame is either moment-resisting (transfers moment, shear, and axial) or pinned (transfers shear only, with rotational release assumed). The lateral system design depends entirely on this distinction being respected consistently across the model.

In practice, connection class errors fall into two categories:

Type A — Wrong class for the bay: A moment connection placed in a braced bay where the analysis assumes pinned behaviour. The frame was designed as a braced frame. The connection was copied from a moment-frame template and not revised. The analysis is unconservative because it assumes zero moment transfer at that joint, but the physical connection will attract moment and may be inadequate for it.

Type B — Right class, wrong component: The engineer intended a moment connection. The detailer used a shear-tab component (pinned) rather than an end plate component (moment) because the section view looked similar. The component dialog confirms the classification — but only if someone opens it.

Automating class vs. pattern checks requires two inputs: (a) the connection component number (which maps to pinned or moment in a lookup table), and (b) the bay classification from the structural analysis model or a manually maintained zone map. The zone map approach is discussed in the automation strategy section.

4. Fastener Compatibility

Fastener compatibility is a three-part check:

Grade vs. application. Under ASTM standards (now consolidated in ASTM F3125), Grade A325 bolts have a minimum tensile strength of 120 ksi. Grade A490 bolts reach 150–173 ksi. ISO 898-1 property class 8.8 has a minimum tensile strength of 800 MPa (approximately 116 ksi) and yield strength of 640 MPa. Property class 10.9 reaches 1040 MPa tensile and 940 MPa yield. The check is: is the specified bolt grade consistent with the connection type and loading category defined in the connection component?

Grade vs. base material. A490 (and equivalent 10.9 metric) bolts must not be used with base plates fabricated from certain structural steels where the tensile stress in the connected element would be driven too high. Specifically, ASTM F3125 prohibits galvanizing A490 bolts because of hydrogen embrittlement risk — a critical detail on projects with corrosion protection requirements. If the model specifies an A490 bolt group and the project specification includes hot-dip galvanizing, that is a conflict that should be flagged.

Standard vs. hole type. Standard holes, oversized holes, short-slotted, and long-slotted all have different load transfer characteristics. If the component is set to long-slotted holes in a direction perpendicular to the slot, load transfer assumptions in the design may not hold.

5. Weld Access and Clearance

This check is primarily geometric but has a design intent dimension. Weld access holes (cope holes) for beam-to-column moment connections require specific geometry per AISC 360-22 Section J1.6 to prevent triaxial stress concentrations at the k-zone. An automated check can flag connections where the component parameters do not include a cope, or where cope dimensions fall outside the specified range, for manual review.

The cope geometry requirement is specific: the radius at the bottom of the weld access hole must be at least 3/8 in (10 mm), and the access hole itself must be free of notches and sharp re-entrant corners. In practice, this means the automated check needs to read the cope dimensions from the connection component's parameters and compare them against the J1.6 requirements. Tekla's standard moment connection components (130, 134) include cope geometry parameters that are accessible via GetAttribute. The check fires when the cope radius parameter is zero (no cope specified) or below the minimum.

6. Stiffener and Continuity Plate Adequacy

For beam-to-column moment connections, column continuity plates (also called transverse stiffeners or column stiffeners) are required when the beam flanges deliver concentrated forces to the column web or flange that exceed the local capacity. AISC 360-22 Sections J10.1 through J10.6 define the limits.

The automated version of this check is a flag, not a calculation. If the column section depth is below a threshold relative to the beam flange width, or if the beam flange thickness exceeds the column flange thickness by more than a specified ratio, the check fires a MEDIUM exception prompting the engineer to verify that continuity plate requirements have been satisfied. This does not replace the calculation — it ensures the calculation is not overlooked.

7. Review Scope Definition: What You Must Document

Before the first run of the review engine, the connection engineer of record must define and document the review scope. This document should answer:

• Which connection types are covered by the rule set? List the component numbers explicitly. Custom connections not in the list are out of scope and must be reviewed by other means.
• Which code edition applies? AISC 360-22 or EN 1993-1-8 (or both for dual-compliance projects). Note the applicable national annex for EC3 projects — the UK national annex, for example, adjusts some EC3 factor values.
• Which checks require force data and are therefore not automated? Bolt shear and bearing, weld group capacity, plate net section, block shear. These must be listed as explicitly excluded from the automated pass.
• What is the zone map based on? Name the structural analysis model revision from which the zone map was derived. Include the revision date.
• What is the acceptance threshold? CRITICAL must resolve. HIGH must be reviewed and accepted or resolved. Below what severity threshold is a documented acceptance acceptable?

Without this document, the exception report is evidence of a run, not evidence of a review. The distinction matters when the project enters construction and an RFI challenges a connection.

Common Mistake Patterns

Understanding which mistakes occur most frequently is the prerequisite for deciding which rules to encode first. The following patterns come from post-review experience across multiple large steelwork packages; they are not hypothetical.

1. Connection Class / Framing Pattern Mismatch

This is the single most consequential class of error and the hardest to catch without systematic model interrogation. The scenario plays out in two directions:

Moment-in-pinned-bay. A connection engineer is detailing a multi-storey office building. The lateral system is a concrete core supplemented by two bays of steel bracing per elevation. All steel beam-to-column connections outside the braced bays are designed and assumed to be pinned. The detailer works through connections using a template. One bay — a corner bay near a stair penetration — has an atypical beam layout. The template used for this bay is the extended end plate template (moment) rather than the flexible end plate template (pinned). The error propagates into the fabrication package. Nobody catches it because the end plate looks right in elevation, and the review was twelve seconds per connection.

Pinned-in-moment-frame. Rarer but more dangerous. The frame analysis assumed moment continuity at a column. The connection is detailed as a simple shear tab. The column is undersized for the sway it will actually experience. This does not typically cause immediate failure, but it changes the mode of behaviour in a lateral event.

How the automation catches it. Each connection component number maps to a class. The model is spatially partitioned into structural zones (braced, moment-frame, pinned). A rule fires when the component class does not match the zone classification. The exception report lists: connection_id | component_number | assigned_class | zone_expected_class | severity.

2. Undersized Fillet Welds

Fillet weld sizing errors are common in two circumstances: when connection details are copied between steel grades (a detail calibrated for S275 may not meet the minimum for S355 if the plate thickness changes), and when standard details are applied to non-standard plate thicknesses without recalibration.

The most common error pattern: a standard shear tab detail specifies a 6 mm fillet weld connecting the tab to the column web. That is adequate for a 10 mm tab (meeting the 3/16 in minimum for the 1/4–1/2 in range under AISC Table J2.4). The same standard detail is copied to a connection where the column web is 22 mm thick — now the thicker part is 22 mm, which falls in the > 19 mm / > 3/4 in category, requiring a minimum of 5/16 in (8 mm). The 6 mm weld is non-compliant.

Under EC3, the effective throat must satisfy the resistance check, but the 3 mm absolute minimum (§4.5.2) and the requirement that the throat thickness is at least 3 mm regardless of calculation mean a similar minimum-size issue can arise when very thin plates are connected with a weld that is technically adequate for stress but geometrically marginal.

3. Bolt Grade vs. Base Material Mismatch

This pattern typically occurs when connection details are migrated across project standards. A detail developed for a UK project (ISO property class 8.8 or 10.9 bolts, S275 or S355 structural steel) is adapted for a US project (A325 or A490, A992 or A572 Grade 50 structural steel). The adaptation usually happens at the template level, but individual connection instances may retain the original bolt standard designation.

Specific conflict patterns to detect:

• A490 + galvanized specification: ASTM F3125 (which supersedes A325 and A490 as separate documents) explicitly prohibits hot-dip galvanizing on Grade A490 bolts because of hydrogen embrittlement risk at high tensile strengths. If the project specification includes galvanizing and the model contains A490 bolt groups, every such instance should be flagged with high severity.

• ISO 10.9 in connections with S235/S275 base metal and thin outstanding legs: Property class 10.9 bolts (940 MPa yield, 1040 MPa tensile) develop very high clamping forces in slip-critical connections. When the connected material is relatively weak (S235 yield at 235 MPa) and the plate geometry is thin, prying action on the bolts may induce bearing stresses that exceed the plate capacity. This is a design check, not just a detailing check, but the model can flag the combination for engineering review.

• Grade mismatch in splice connections: Splice connection templates sometimes contain mixed bolt grades across bolt groups — for example, A325 bolts in the web splice and A490 bolts in the flange splice of the same connection instance. This is not automatically incorrect, but it should be flagged for human verification because it complicates the field torquing procedure and increases the risk of installation error.

4. Orientation Errors

Orientation errors are particularly common in end plate connections and in connections at skewed beams. The typical end plate orientation error:

• The beam frames into a column at an angle (plan view skew). The end plate is modelled flat (perpendicular to the column face) rather than cut at the skew angle. The result is that the bolt holes in the end plate do not align with the column face.

• The end plate is modelled correctly for an even flange-to-flange connection but placed on a beam with significant slope, creating an unequal weld distance top and bottom that may violate the minimum weld requirements on the acute side.

• The top and bottom of a moment end plate are transposed — the stiffened half is on the opposite side from the compression flange. This is cosmetically plausible in Tekla's 3D view but changes the structural behaviour of the connection under sagging/hogging loads.

Orientation checks are harder to automate fully because they require comparing the component's geometric orientation to the beam's local axis. A partial check — comparing the connection's position attribute against the beam's end orientation vector — is implementable in the Open API and catches the common cases.

5. Hidden Plate-to-Plate Weld Conflicts

Complex multi-member connections — column trees, transfer nodes, large moment frames — often have multiple plates welded to the same column face or web. A common configuration is a shear tab welded to the column web at the same elevation as a horizontal stiffener plate. If the weld footprint of the shear tab overlaps with the stiffener plate, a plate-to-plate weld conflict exists: the fabricator cannot physically deposit both welds as designed.

This is primarily a geometry clash, but standard clash detection does not reliably catch weld conflicts because welds are not typically modelled as solid bodies. The check requires comparing the weld footprint (derived from the component's weld parameters) against the extents of adjacent plates. Partial automation is achievable; full automation requires modelling weld geometry explicitly, which is non-trivial.

6. Standard Detail Used Outside Its Scope

Every standard connection detail has an implicit scope: it was designed for a specific bolt size range, a specific plate thickness range, a specific span of beam depth. When that detail is applied outside its design scope — commonly via a global template applied to all connections of a given type regardless of size — the detail may be geometrically compatible but structurally inadequate.

The automated check compares the beam depth, flange width, and web thickness at the connection against the scope parameters encoded in the rule for that component number. Out-of-scope applications are flagged for individual engineering review.

Automation Strategy

The automation architecture described here has three layers:

1. Rule definitions — YAML files that encode the logic for each check. These are version-controlled separately from the executable and can be updated by the engineer-of-record without recompiling.

2. Rule engine — A C# application that reads the Tekla model via the Open API, evaluates each rule against each connection, and writes the exception report.

3. Exception triage — The output CSV reviewed by the engineer, with severity tiers determining the response action.

Architecture Overview

Reading the Tekla Model

The entry point is a standard Tekla Open API model connection. The ModelObjectSelector class provides access to all model objects; the rule engine filters to connections and components.

// ConnectionReviewEngine.cs
// Requires: Tekla.Structures.Model, Tekla.Structures, Tekla.Structures.Datatype
// Tekla Open API — Tekla Structures 2024/2025
// Reference: developer.tekla.com/documentation/how-tekla-open-api-works
 
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Tekla.Structures.Model;
using Tekla.Structures.Geometry3d;
using Tekla.Structures;
 
namespace BimMobius.ConnectionReview
{
    public class ConnectionReviewEngine
    {
        private readonly Model _model;
        private readonly List<ReviewRule> _rules;
        private readonly List<ExceptionRecord> _exceptions = new();
 
        public ConnectionReviewEngine(List<ReviewRule> rules)
        {
            _model = new Model();
            if (!_model.GetConnectionStatus())
                throw new InvalidOperationException(
                    "Tekla Structures is not running or the model is not open.");
            _rules = rules;
        }
 
        public IReadOnlyList<ExceptionRecord> Run()
        {
            _exceptions.Clear();
 
            // Walk all model objects and process connections
            var selector = _model.GetModelObjectSelector();
            var enumerator = selector.GetAllObjects(
                new System.Type[] { typeof(Connection) });
 
            while (enumerator.MoveNext())
            {
                if (enumerator.Current is Connection connection)
                    EvaluateConnection(connection);
            }
 
            return _exceptions.AsReadOnly();
        }
 
        private void EvaluateConnection(Connection connection)
        {
            var context = BuildContext(connection);
            if (context == null) return;
 
            foreach (var rule in _rules)
            {
                var result = rule.Evaluate(context);
                if (!result.Passed)
                {
                    _exceptions.Add(new ExceptionRecord
                    {
                        ConnectionId   = connection.Identifier.ID.ToString(),
                        ComponentName  = context.ComponentName,
                        ComponentNumber = context.ComponentNumber,
                        RuleId         = rule.Id,
                        RuleDescription = rule.Description,
                        Detail         = result.Detail,
                        Severity       = rule.Severity,
                        Location       = context.LocationDescription
                    });
                }
            }
        }
 
        private ConnectionContext BuildContext(Connection connection)
        {
            try
            {
                connection.Select();
 
                string componentName = string.Empty;
                int componentNumber  = 0;
                connection.GetAttribute("COMPONENT_NUMBER", ref componentNumber);
                connection.GetAttribute("NAME", ref componentName);
 
                // Get primary and secondary parts
                var input = connection.GetComponentInput();
                var primaryPartId  = input?.Count > 0 ? input[0] : null;
                var secondaryPartId = input?.Count > 1 ? input[1] : null;
 
                // Get child objects (bolts, welds)
                var children = new List<ModelObject>();
                var childEnum = connection.GetChildren();
                if (childEnum != null)
                {
                    while (childEnum.MoveNext())
                        children.Add((ModelObject)childEnum.Current);
                }
 
                var bolts = children.OfType<BoltGroup>().ToList();
                var welds = children.OfType<Weld>().ToList();
 
                // Resolve primary beam/column to get plate thicknesses
                Beam primaryBeam = null;
                if (primaryPartId != null)
                    primaryBeam = _model.SelectModelObject(
                        new Identifier(primaryPartId.GetHashCode())) as Beam;
 
                return new ConnectionContext
                {
                    Connection        = connection,
                    ComponentNumber   = componentNumber,
                    ComponentName     = componentName,
                    Bolts             = bolts,
                    Welds             = welds,
                    PrimaryBeam       = primaryBeam,
                    LocationDescription = GetLocationDescription(connection)
                };
            }
            catch (Exception ex)
            {
                // Log but do not stop the run — a parse failure on one
                // connection should not halt the review of 5000 others.
                Console.Error.WriteLine(
                    $"Context build failed for {connection.Identifier.ID}: {ex.Message}");
                return null;
            }
        }
 
        private static string GetLocationDescription(Connection connection)
        {
            // Extract a human-readable location for the exception report
            // so the reviewer can find the connection in the model.
            var pos = connection.GetCoordinateSystem()?.Origin;
            if (pos == null) return "unknown";
            return $"X={pos.X:F0} Y={pos.Y:F0} Z={pos.Z:F0} mm";
        }
    }
}

Rule Definitions

Rules are defined in YAML and loaded at runtime. This separation means the structural engineer can adjust thresholds, add project-specific logic, or exclude certain component numbers without touching the C# code.

# connection-review-rules.yaml
# Rule definitions for automated connection review
# Version: 1.0.0 — BIM Mobius connection review engine
# References:
#   - AISC 360-22 Section J2.2b, Table J2.4 (fillet weld minimums)
#   - AISC 360-22 Section J3.4, Table J3.4 (bolt spacing and edge distances)
#   - EN 1993-1-8 §4.5.2 (EC3 fillet weld minimum throat)
#   - ASTM F3125 (A325, A490 bolt grades)
#   - ISO 898-1 (property class 8.8, 10.9)
 
code_standard: AISC-360-22  # switch to EC3 for European projects
severity_levels:
  - CRITICAL   # Structural compliance failure — must resolve before IFC
  - HIGH        # Likely non-compliance — engineer must review
  - MEDIUM      # Possible non-compliance or scope mismatch — review recommended
  - LOW         # Best-practice deviation — note and close or accept
 
rules:
 
  - id: WLD-001
    description: >
      Fillet weld size below AISC 360-22 Table J2.4 minimum for thicker
      joined part. Applies to weld-to-column-web and weld-to-column-flange
      welds in shear tab and end plate connections.
    severity: CRITICAL
    standard_ref: "AISC 360-22 §J2.2b, Table J2.4"
    check_type: weld_minimum_size
    parameters:
      thickness_ranges_inch:
        - { max_thicker_part: 0.25, min_weld_size: 0.125 }  # <= 1/4" -> 1/8"
        - { max_thicker_part: 0.5,  min_weld_size: 0.1875 } # 1/4"-1/2" -> 3/16"
        - { max_thicker_part: 0.75, min_weld_size: 0.25   } # 1/2"-3/4" -> 1/4"
        - { max_thicker_part: 999,  min_weld_size: 0.3125 } # > 3/4" -> 5/16"
      note: >
        Cap minimum at thinner part thickness per §J2.2b exception.
        Size in inches; multiply by 25.4 for mm comparison.
 
  - id: WLD-002
    description: >
      EC3 fillet weld effective throat below 3 mm absolute minimum.
      EN 1993-1-8 §4.5.2. Flags welds where throat a < 3 mm regardless
      of resistance calculation outcome.
    severity: CRITICAL
    standard_ref: "EN 1993-1-8 §4.5.2"
    check_type: weld_throat_ec3
    parameters:
      min_throat_mm: 3.0
 
  - id: WLD-003
    description: >
      Fillet weld exceeds maximum size per AISC 360-22 §J2.2b. For plates
      >= 1/4", weld must not exceed plate thickness minus 1/16".
    severity: HIGH
    standard_ref: "AISC 360-22 §J2.2b"
    check_type: weld_maximum_size
 
  - id: CLX-001
    description: >
      Moment connection component (class = MOMENT) found in a zone
      classified as BRACED_PINNED in the zone map. This creates a
      class/framing-pattern mismatch: the structural analysis assumed
      pinned behaviour; the physical connection resists moment.
    severity: CRITICAL
    check_type: class_vs_zone
    parameters:
      disallowed_in_zones:
        - BRACED_PINNED
      moment_component_numbers:
        # Tekla standard moment connection components
        # Ref: support.tekla.com/doc/tekla-structures/2025/com_steel_moment_connections
        - 130   # Moment connection (welded column, bolted beam)
        - 134   # Bolted moment connection
        - 144   # End plate (moment end plate variant — check parameter P2)
        - 181   # Moment connection with shear tab
 
  - id: CLX-002
    description: >
      Pinned shear connection component found in a zone classified as
      MOMENT_FRAME. The analysis assumed moment continuity; the connection
      provides shear transfer only.
    severity: CRITICAL
    check_type: class_vs_zone
    parameters:
      disallowed_in_zones:
        - MOMENT_FRAME
      pinned_component_numbers:
        - 29    # Simple end plate
        - 32    # Simple end plate (two-sided)
        - 59    # Shear tab
        - 146   # Single plate shear connection
 
  - id: BLT-001
    description: >
      A490 (or ISO 10.9) bolt specified in a connection where the project
      specification includes hot-dip galvanizing. ASTM F3125 prohibits
      galvanizing Grade A490 bolts (hydrogen embrittlement risk).
    severity: CRITICAL
    standard_ref: "ASTM F3125, §6.1 coating restrictions"
    check_type: bolt_grade_galvanizing_conflict
    parameters:
      incompatible_grades:
        - "A490"
        - "F3125-A490"
        - "10.9"
      project_has_galvanizing: true  # set from project config
 
  - id: BLT-002
    description: >
      Bolt grade does not match project specification. Flags any bolt
      standard designation not in the project-approved list.
    severity: HIGH
    check_type: bolt_grade_whitelist
    parameters:
      approved_standards:
        - "A325"
        - "A490"
        - "F3125-A325"
        - "F3125-A490"
        # For metric projects, replace with: "8.8", "10.9"
 
  - id: BLT-003
    description: >
      Mixed bolt grades within a single connection (e.g. A325 web bolts +
      A490 flange bolts). Not automatically wrong, but flags for review
      as it complicates field installation and torque sequencing.
    severity: MEDIUM
    check_type: mixed_bolt_grades_in_connection
 
  - id: BLT-004
    description: >
      Bolt footprint violates minimum edge distance per AISC 360-22
      Table J3.4. Minimum edge distance from centre of standard hole to
      nearest edge: 1.0" for 5/8" bolts, 1.25" for 3/4", 1.5" for 7/8",
      1.75" for 1", 2.0" for 1-1/8" and above.
    severity: HIGH
    standard_ref: "AISC 360-22 Table J3.4"
    check_type: bolt_edge_distance
    parameters:
      min_edge_distance_by_diameter_inch:
        0.625: 1.0
        0.75:  1.25
        0.875: 1.5
        1.0:   1.75
        1.125: 2.0
        1.25:  2.25
 
  - id: ORI-001
    description: >
      End plate orientation inconsistent with beam slope. For beams with
      slope > 2 degrees, end plate should be cut to match the beam end
      angle. Flags connections where end plate normal vector diverges from
      beam end axis by more than 2 degrees.
    severity: MEDIUM
    check_type: end_plate_orientation
    parameters:
      tolerance_degrees: 2.0
      applicable_components: [144, 27, 65, 97]

Rule Engine — Evaluating Individual Rules

The engine loads rules from YAML and dispatches to typed evaluators. The key evaluators for the rules above are shown below.

// RuleEvaluators.cs
 
namespace BimMobius.ConnectionReview
{
    /// <summary>
    /// Evaluates WLD-001: minimum fillet weld size per AISC 360-22 Table J2.4.
    /// The minimum is based on the THICKER of the two joined parts.
    /// §J2.2b exception: if the minimum exceeds the thinner part thickness,
    /// cap at the thinner part thickness.
    /// </summary>
    public class WeldMinimumSizeEvaluator : IRuleEvaluator
    {
        public RuleResult Evaluate(ConnectionContext ctx, ReviewRule rule)
        {
            foreach (var weld in ctx.Welds)
            {
                weld.Select();
 
                double weldSize = weld.Size; // leg size in mm
                double thickerPartMm  = Math.Max(weld.MainObjectThickness,
                                                  weld.SecondaryObjectThickness);
                double thinnerPartMm  = Math.Min(weld.MainObjectThickness,
                                                  weld.SecondaryObjectThickness);
 
                double thickerPartInch = thickerPartMm / 25.4;
                double thinnerPartInch = thinnerPartMm / 25.4;
                double weldSizeInch    = weldSize / 25.4;
 
                // Look up AISC Table J2.4 minimum for thicker part
                double minFromTable = GetAiscTableJ24Minimum(thickerPartInch);
 
                // §J2.2b exception: cap at thinner part thickness
                double effectiveMin = Math.Min(minFromTable, thinnerPartInch);
                double effectiveMinMm = effectiveMin * 25.4;
 
                if (weldSize < effectiveMinMm - 0.1) // 0.1 mm tolerance
                {
                    return RuleResult.Fail(
                        $"Weld size {weldSize:F1} mm < required {effectiveMinMm:F1} mm. " +
                        $"Thicker part = {thickerPartMm:F1} mm, " +
                        $"thinner part = {thinnerPartMm:F1} mm. " +
                        $"AISC 360-22 Table J2.4 minimum = {minFromTable * 25.4:F1} mm, " +
                        $"effective after §J2.2b exception = {effectiveMinMm:F1} mm.");
                }
            }
            return RuleResult.Pass();
        }
 
        private static double GetAiscTableJ24Minimum(double thickerPartInch)
        {
            // AISC 360-22 Table J2.4
            // Source: steelcalculator.app/reference/min-weld-size/
            if (thickerPartInch <= 0.25)  return 0.125;  // 1/8"
            if (thickerPartInch <= 0.5)   return 0.1875; // 3/16"
            if (thickerPartInch <= 0.75)  return 0.25;   // 1/4"
            return 0.3125;                                // 5/16"
        }
    }
 
    /// <summary>
    /// Evaluates CLX-001/CLX-002: connection class vs. structural zone.
    /// Zone classification is loaded from an external zone map CSV
    /// that maps grid intersections to structural zone types.
    /// </summary>
    public class ClassVsZoneEvaluator : IRuleEvaluator
    {
        private readonly ZoneMap _zoneMap;
 
        public ClassVsZoneEvaluator(ZoneMap zoneMap)
        {
            _zoneMap = zoneMap;
        }
 
        public RuleResult Evaluate(ConnectionContext ctx, ReviewRule rule)
        {
            var disallowedZones = rule.Parameters["disallowed_in_zones"]
                as List<string> ?? new List<string>();
            var flaggedComponents = rule.Parameters["moment_component_numbers"]
                as List<int> ?? new List<int>();
 
            if (!flaggedComponents.Contains(ctx.ComponentNumber))
                return RuleResult.Pass(); // Rule does not apply to this component
 
            var zone = _zoneMap.GetZone(ctx.Connection.GetCoordinateSystem()?.Origin);
            if (zone == null)
                return RuleResult.Pass(); // No zone data — cannot evaluate
 
            if (disallowedZones.Contains(zone.Classification))
            {
                return RuleResult.Fail(
                    $"Component {ctx.ComponentNumber} ({ctx.ComponentName}) " +
                    $"is a moment connection but is located in zone " +
                    $"'{zone.Id}' classified as '{zone.Classification}'. " +
                    $"Analysis assumes pinned behaviour at this location.");
            }
 
            return RuleResult.Pass();
        }
    }
 
    /// <summary>
    /// Evaluates BLT-001: A490 bolt + galvanized project = conflict.
    /// ASTM F3125 prohibits hot-dip galvanizing on Grade A490 fasteners.
    /// Source: portlandbolt.com/technical/faqs/what-is-the-difference-between-astm-a490-and-astm-a325-bolts
    /// </summary>
    public class BoltGradeGalvanizingEvaluator : IRuleEvaluator
    {
        public RuleResult Evaluate(ConnectionContext ctx, ReviewRule rule)
        {
            var incompatibleGrades = rule.Parameters["incompatible_grades"]
                as List<string> ?? new List<string>();
            bool projectHasGalvanizing = rule.Parameters.TryGetValue(
                "project_has_galvanizing", out var galvFlag)
                && (bool)galvFlag;
 
            if (!projectHasGalvanizing) return RuleResult.Pass();
 
            foreach (var bolt in ctx.Bolts)
            {
                bolt.Select();
                string standard = bolt.BoltStandard ?? string.Empty;
 
                if (incompatibleGrades.Any(g =>
                    standard.IndexOf(g, StringComparison.OrdinalIgnoreCase) >= 0))
                {
                    return RuleResult.Fail(
                        $"Bolt standard '{standard}' (A490 / 10.9 class) " +
                        $"in connection {ctx.ComponentName} — project specification " +
                        $"includes hot-dip galvanizing. ASTM F3125 prohibits " +
                        $"galvanizing Grade A490 fasteners (hydrogen embrittlement). " +
                        $"Replace with A325 or specify mechanical zinc coating.");
                }
            }
            return RuleResult.Pass();
        }
    }
 
    /// <summary>
    /// Evaluates BLT-004: bolt edge distance per AISC 360-22 Table J3.4.
    /// </summary>
    public class BoltEdgeDistanceEvaluator : IRuleEvaluator
    {
        public RuleResult Evaluate(ConnectionContext ctx, ReviewRule rule)
        {
            var minEdgeByDia = rule.Parameters["min_edge_distance_by_diameter_inch"]
                as Dictionary<double, double> ?? new Dictionary<double, double>();
 
            foreach (var boltGroup in ctx.Bolts)
            {
                boltGroup.Select();
 
                double diaInch = boltGroup.BoltSize / 25.4;
                double lookupDia = minEdgeByDia.Keys
                    .OrderBy(k => Math.Abs(k - diaInch))
                    .First();
                double minEdgeInch = minEdgeByDia[lookupDia];
                double minEdgeMm   = minEdgeInch * 25.4;
 
                // BoltPositions gives the 3D coordinates of each bolt
                // Edge distance check requires the connected plate extents —
                // simplified here as a component attribute lookup.
                double edgeMm = 0;
                boltGroup.GetAttribute("EDGE_DISTANCE_X", ref edgeMm);
 
                if (edgeMm > 0 && edgeMm < minEdgeMm - 0.5)
                {
                    return RuleResult.Fail(
                        $"Bolt edge distance {edgeMm:F1} mm < AISC Table J3.4 " +
                        $"minimum {minEdgeMm:F1} mm for {boltGroup.BoltSize:F0} mm " +
                        $"diameter bolts. Standard: {boltGroup.BoltStandard}.");
                }
            }
            return RuleResult.Pass();
        }
    }
}

Exception Report Generation

The output is a CSV that can be sorted, filtered, and imported into the project's issue register or RFI tracking sheet.

// ExceptionReportWriter.cs
 
public class ExceptionReportWriter
{
    public void Write(
        IEnumerable<ExceptionRecord> exceptions,
        string outputPath,
        string modelName,
        string runDate)
    {
        using var writer = new StreamWriter(outputPath);
 
        // Header
        writer.WriteLine(
            "RUN_DATE,MODEL,CONNECTION_ID,COMPONENT_NUMBER,COMPONENT_NAME," +
            "RULE_ID,RULE_DESCRIPTION,SEVERITY,DETAIL,LOCATION");
 
        // Sort: CRITICAL first, then HIGH, MEDIUM, LOW
        var ordered = exceptions.OrderBy(e => SeverityOrder(e.Severity));
 
        foreach (var e in ordered)
        {
            writer.WriteLine(string.Join(",",
                runDate,
                EscapeCsv(modelName),
                e.ConnectionId,
                e.ComponentNumber,
                EscapeCsv(e.ComponentName),
                e.RuleId,
                EscapeCsv(e.RuleDescription),
                e.Severity,
                EscapeCsv(e.Detail),
                EscapeCsv(e.Location)));
        }
    }
 
    private static int SeverityOrder(string severity) => severity switch
    {
        "CRITICAL" => 0,
        "HIGH"     => 1,
        "MEDIUM"   => 2,
        "LOW"      => 3,
        _          => 9
    };
 
    private static string EscapeCsv(string value)
    {
        if (string.IsNullOrEmpty(value)) return string.Empty;
        if (value.Contains(',') || value.Contains('"') || value.Contains('\n'))
            return $"\"{value.Replace("\"", "\"\"")}\"";
        return value;
    }
}

Sample Exception Report

The following is a representative exception report from a 3,400-connection model. Thirty-one exceptions were raised from a population of 3,400 connections. The engineer reviewed thirty-one items instead of three thousand four hundred.

RUN_DATE,MODEL,CONNECTION_ID,COMPONENT_NUMBER,COMPONENT_NAME,RULE_ID,RULE_DESCRIPTION,SEVERITY,DETAIL,LOCATION
2026-05-14,Tower_C_S05,443921,130,Moment connection,CLX-001,Moment connection in pinned bay,CRITICAL,"Component 130 (Moment connection) in zone B3 classified as BRACED_PINNED. Analysis assumes pinned.",X=14200 Y=8400 Z=12300 mm
2026-05-14,Tower_C_S05,443788,130,Moment connection,CLX-001,Moment connection in pinned bay,CRITICAL,"Component 130 in zone C2 classified as BRACED_PINNED.",X=28100 Y=8400 Z=12300 mm
2026-05-14,Tower_C_S05,112034,59,Shear tab,WLD-001,Fillet weld below AISC J2.4 minimum,CRITICAL,"Weld size 6.0 mm < required 8.0 mm. Thicker part = 22.4 mm (column web). Table J2.4 minimum = 7.94 mm.",X=0 Y=12600 Z=16800 mm
2026-05-14,Tower_C_S05,112198,59,Shear tab,WLD-001,Fillet weld below AISC J2.4 minimum,CRITICAL,"Weld size 6.0 mm < required 8.0 mm. Thicker part = 21.1 mm.",X=14200 Y=12600 Z=16800 mm
2026-05-14,Tower_C_S05,889432,144,End plate,BLT-001,A490 bolt in galvanized spec,CRITICAL,"Bolt standard 'F3125-A490' in galvanized project. ASTM F3125 prohibits HDG on A490.",X=7100 Y=0 Z=9600 mm
2026-05-14,Tower_C_S05,774312,144,End plate,BLT-004,Bolt edge distance below AISC J3.4,HIGH,"Edge distance 28.0 mm < minimum 31.75 mm for M20 (3/4\") bolts.",X=21300 Y=16800 Z=9600 mm
2026-05-14,Tower_C_S05,553109,29,Simple end plate,ORI-001,End plate orientation vs beam slope,MEDIUM,"End plate normal diverges 3.4 deg from beam axis. Beam slope = 3.6 deg. Check weld geometry.",X=7100 Y=8400 Z=6200 mm

Five critical exceptions, one high, one medium — from 3,400 connections. The five criticals require engineering action before IFC release. The high is reviewed and either resolved or accepted with a documented rationale. The medium is noted.

Integrating with the Engineer's Workflow

The automation adds one step to the standard IFC preparation workflow:

1. Model preparation

   Detailer completes connection modelling. All connections have component numbers assigned. Bolt standards and weld sizes are set from templates.

2. Zone map preparation

   Structural engineer (or designated BIM coordinator) prepares the zone classification map as a CSV: grid reference, zone ID, zone classification (BRACED_PINNED, MOMENT_FRAME, GRAVITY_ONLY). This takes 30–60 minutes for a typical commercial project and is stored alongside the model.

3. Rule engine run

   The rule engine is executed against the current model. Runtime is typically 3–8 minutes for 5,000 connections on a local machine. The exception report is written to the project's QA folder.

4. Exception triage

   The lead connection engineer opens the exception report. CRITICAL items are actioned or escalated. HIGH items are reviewed individually. MEDIUM and LOW items are closed with a documented rationale or converted to detailing instructions.

5. Re-run after corrections

   Once corrections are made, the rule engine re-runs. The exception count should converge to zero CRITICAL and zero HIGH. Residual MEDIUM/LOW items are reviewed and either resolved or formally accepted.

6. IFC release

   The IFC is released with a QA record attached: engine version, rule set version, run date, exception count at release, and a statement of which exceptions were accepted with rationale.

Severity Ranking Logic

The severity tier of an exception determines the workflow response. The assignment is not arbitrary:

The rule YAML sets the default severity for each rule. The engine allows severity to be overridden at the instance level: if the engineer reviews an exception and accepts it, the acceptance is recorded in a companion YAML file that is re-read on the next run, suppressing the re-flagging of accepted items.

Specific Rule Deep Dives

Rule CLX-001: Moment vs. Pinned in Braced Bays

This rule requires the zone map. The zone map is a lightweight CSV with one row per structural bay (or per grid intersection, depending on framing complexity):

ZONE_ID,GRID_X_FROM,GRID_X_TO,GRID_Y_FROM,GRID_Y_TO,FLOOR_FROM,FLOOR_TO,CLASSIFICATION
B1,0,14200,0,8400,0,50000,BRACED_PINNED
B2,14200,28100,0,8400,0,50000,GRAVITY_ONLY
B3,28100,42300,0,8400,0,50000,MOMENT_FRAME
C1,0,14200,8400,16800,0,50000,GRAVITY_ONLY
C2,14200,28100,8400,16800,0,50000,BRACED_PINNED

The engine loads this zone map and performs a point-in-zone lookup for each connection's origin coordinate. The lookup is a simple AABB (axis-aligned bounding box) test per row, O(n × m) with n connections and m zones. For typical projects (< 50 zones), this is trivial.

The moment component number list in the rule YAML must be maintained for each project — it maps Tekla component numbers to structural classification. The default list covers the standard Tekla moment components (130, 134, 144 with moment parameter, 181). Custom connections and third-party components require a project-specific addition.

Rule BLT-002: Bolt Grade vs. Base Material

The bolt grade whitelist check compares each bolt group's BoltStandard attribute against the project-approved list. For multi-standard projects (US imperial bolts in some packages, metric ISO bolts in others), the whitelist is split by package and loaded from the project configuration.

The more sophisticated version of this rule compares bolt grade against base material grade. This requires the steel grade of the connected parts, which is available as a material attribute on the Beam and Column objects. The check:

• A490 / 10.9 bolts in bearing-type connections where the base material is S235 or A36 (lower yield) on thin plates with short edge distances warrants a capacity check flag.
• A325 / 8.8 bolts in a connection designed for slip-critical (Class A or Class B surface) must have the correct surface condition specified.

Rule WLD-001 / WLD-002: Fillet Size vs. Base Thickness

The AISC check (WLD-001) reads the weld size and the thickness of the thicker joined part from the weld object attributes. The EC3 check (WLD-002) reads the effective throat attribute. Both checks apply a small tolerance (0.1 mm for WLD-001, 0.0 mm for WLD-002 since EC3 states an absolute minimum) to avoid false positives from rounding in the Tekla model.

A known source of false positives: Tekla models welds with size as leg length (the metric 'z' value) or as effective throat (the 'a' value) depending on the weld type and the Tekla version. The rule engine checks the weld type attribute and applies the appropriate conversion: effective throat a = 0.707 × leg length z for equal-leg welds. For unequal-leg welds, the conversion is more complex and the rule conservatively flags any weld where the ratio is outside the 0.6–0.75 range for manual review.

Rule BLT-004: Bolt Placement Footprint

The edge distance check reads the bolt group positions and, ideally, the extents of the connected plate. In practice, the plate extents are not always accessible as direct attributes; the check uses the component's edge distance parameter where it exists, or derives the distance from the bolt position relative to the connection origin vector.

For connections where the edge distance is not available as a named attribute, the rule is downgraded from HIGH to MEDIUM severity and the detail is annotated "Edge distance parameter not resolved — manual verification required." This is preferable to a false pass (pretending the check ran when it did not).

Rule ORI-001: End Plate Orientation

The end plate orientation check compares the normal vector of the end plate (derived from the component's coordinate system) to the beam's end vector. A divergence of more than the tolerance (default 2 degrees) fires the rule. The tolerance is configurable because heavily sloped roofs or architecturally shaped frames may have legitimate orientation divergences that are handled by a fabrication-drawing note rather than a model change.

Anti-Patterns

Understanding where automated connection review goes wrong is as important as understanding how to build it. The following anti-patterns have each produced real project consequences.

Anti-Pattern 1: Replacing Engineering Review with Automation

The exception report is not a certificate of adequacy. It confirms that the connections which passed the rules did not trip any of the rules that were encoded. It says nothing about:

• Connections that are geometrically valid but structurally inadequate under the actual applied loads (force-based adequacy is not checked).
• Connections that are code-compliant for detailing but use the wrong connection type for the structural behaviour (a rule can catch class vs. zone mismatches, but only if the zone map is correct).
• Custom connections or non-standard component numbers that the rule engine has not been configured to evaluate.
• Model objects that the API cannot read correctly due to corruption, missing attributes, or version migration artefacts.

The correct framing: automation narrows the review surface. It does not replace the engineer's responsibility to review connections.

Anti-Pattern 2: No Exception Triage

The exception report is only useful if someone reads it and acts on it. A common failure mode: the report is generated, the CRITICAL count is noted as "acceptable" by the BIM manager without engineering review, and the model is released. Three months later, a fabricator RFI reveals that four of the CRITICAL weld size flags were valid non-compliant details.

Triage discipline requires a named engineer to sign off each exception. The exception report should not be closeable by the BIM coordinator; it needs a structural engineering approval record. In practice, this means the CRITICAL and HIGH rows need an "Approved by" column and a date field, and the completion of this record is a gate for IFC release.

Anti-Pattern 3: Ignoring Rule False Positives

False positives erode trust in the tool. If the weld minimum size rule fires on every correctly-detailed shear tab because the Tekla model represents welds as effective throat rather than leg size, and nobody investigates why, the engineering team will start ignoring the output. Once the output is ignored, the automation provides no protection.

The response to systematic false positives is to investigate and fix the rule, not to accept the false positives as noise. Fix the unit conversion logic, add the weld type conditional, update the tolerance. Log the fix in the rule changelog so the next project team can see that it was addressed.

Anti-Pattern 4: Single-Rule Replacement of Engineering Review

A particularly dangerous pattern in high-pressure schedules: the team agrees that "if the weld size rule passes, the welds are fine." This is scope reduction dressed as efficiency. The weld size rule checks one necessary condition (size relative to thickness) and says nothing about weld type (fillet vs. partial penetration), weld access, weld process compatibility with the base material, or the stress state the weld will experience. Passing one detailing rule does not clear the weld for structural adequacy.

The rule set should be presented to the project team as a list of what it checks and — explicitly — what it does not check. The "does not check" list should appear in the project QA record alongside the exception report.

Anti-Pattern 5: Stale Zone Map

The zone map is derived from the structural analysis model. If the analysis model changes mid-project — a lateral system revision, an added moment frame, a reclassified braced bay — and the zone map is not updated, the class vs. zone rules will give incorrect results. The zone map needs a version number and a reference to the analysis model revision it was derived from. The rule engine should refuse to run with an out-of-date zone map (compared against the model revision date stamp).

Anti-Pattern 6: Automating the Wrong Connections First

Not all connection types carry equal risk. Moment connections in a lateral system are critical; secondary beam clip angle connections in a non-seismic gravity frame carry much lower consequence of error. The rule set development effort should be proportional to structural consequence. Building elaborate rules for secondary framing connections while leaving moment frame connections on a simple component-number whitelist is an inverted risk profile.

A risk-tiered approach to rule development prioritises in this order:

1. Lateral system connections — moment frames, braced frames, shear walls. Errors here affect overall structural behaviour under lateral loads. Rules: CLX-001, CLX-002 (class vs. zone), plus any seismic-specific rules if AISC 341 applies.

2. Transfer structure connections — elements carrying multiple columns or spanning large gravity loads through a transfer level. Rules: WLD-001/002 (weld minimums), BLT-004 (edge distances), BLT-001 (bolt grade/galvanizing).

3. Primary frame connections — standard beam-to-column connections in the main gravity system. Rules: BLT-002 (bolt grade whitelist), WLD-001, ORI-001 (orientation).

4. Secondary and tertiary framing — secondary beams, purlins, girts, bracing cleats. Rules: BLT-002 (grade whitelist only), WLD-001 if time permits.

Spending 40% of the rule development time on secondary framing — which represents perhaps 2% of the structural risk — is a resource allocation failure. Most practitioners discover this the hard way on the first project and correct it on the second.

Anti-Pattern 7: Treating the Rule Set as Static

A rule set that is correct for one project may be partially wrong for the next. The AISC minimum weld size thresholds are stable (they have not changed in recent editions). The component number lookup tables are not stable — Tekla updates component numbers between major versions, third-party connection components use different numbering schemes, and project-specific custom components have entirely novel numbers.

The rule YAML must be reviewed at the start of each project against the current Tekla version's component catalogue. A component number that was valid in the 2023 Tekla catalogue may have been superseded in 2025. If the rule set is treated as a set-and-forget library, it will silently fail to evaluate connections that use the updated component numbers.

The maintenance protocol is straightforward: include a tekla_version field in the rule YAML header, add a startup check in the rule engine that logs a warning if the running Tekla version does not match the version the rules were validated against, and schedule a rule set review as part of the project initiation checklist alongside the BEP and the model template review.

Case Studies

Case Study 1: Transfer Level Connections — Commercial Tower, 3,400 Connections

Project context. A 28-storey commercial office tower. Transfer structure at level 5: heavy plate girders transferring columns above. Multiple connection types in close proximity: moment end plates, shear tabs, stiffener-to-web welds, base plate connections. Total model: 3,400 connections.

Problem before automation. The connection review for the IFC package was assigned to two senior engineers over four days. On day three, the engineers reported that they had reviewed approximately 1,200 connections in detail and were sampling the remaining 2,200. The sampling rate on the remaining connections was approximately one in eight — below the threshold where a systematic error in a template detail would be reliably detected.

Automation implementation. The rule engine was implemented in two days by the BIM team (a Tekla developer and a structural engineer working the rule definitions). The zone map took four hours: the structural engineer mapped twelve structural zones from the analysis model notes.

Result. First run: 47 exceptions. After engineering triage:

• 6 CRITICAL: 2 × moment connections in pinned bays (CLX-001), 4 × weld minimum size failures on transfer-level shear tabs (WLD-001, all on the same standard detail applied to 22 mm+ column webs).
• 9 HIGH: Primarily bolt grade whitelist mismatches (BLT-002) where a metric bolt standard from an earlier project had survived template migration.
• 14 MEDIUM: End plate orientation flags on sloped members within the architect's feature staircase (ORI-001, all accepted after manual review).
• 18 LOW: Bolt grade mixed within single connection (BLT-003, all accepted as intentional design choices after review).

The four weld deficiencies were a single template propagated to 62 connection instances. All 62 were identified in the exception report; manual sampling had found two of the four on day three of the prior review.

Engineering time on exceptions: Three hours for the lead engineer to triage all 47 exceptions, document decisions, and brief the detailer on required corrections. Second run: 0 CRITICAL, 0 HIGH, 14 MEDIUM accepted with rationale.

Case Study 2: Industrial Facility — Bolt Grade Migration Audit

Project context. A process plant structure originally designed to European standards (S355 steel, 8.8/10.9 metric bolts, EC3 compliance). Mid-project, the owner changed jurisdiction to a US-code project (A572 Grade 50 steel, ASTM bolt grades, AISC 360 compliance). The structural model was migrated, but the bolt standard attributes in the Tekla model were not systematically updated.

Problem. The migration was managed manually, with the detailing team updating bolt standards connection by connection. There was no automated check to confirm that every connection had been updated. The model had 1,100 connections; the team estimated coverage at "about 95%." Fifty-five connections with retained ISO metric bolt designations would have entered fabrication with a non-compliant specification.

Automation. The bolt grade whitelist rule (BLT-002) was configured with the post-migration approved list (A325, A490, F3125-A325, F3125-A490) and run against the model. First run: 61 HIGH exceptions, all BLT-002 bolt grade whitelist mismatches. Six were the 55 estimated by the team plus 6 additional connections that had been re-detailed after the initial migration and had reverted to the metric standard.

All 61 were corrected. Second run: 0 exceptions. The entire exercise took one hour of engineering time for triage and three hours of detailer time for corrections.

Key learning. Manual audit of 1,100 connections to verify a single attribute would have taken 4–6 hours and might have missed the 6 re-detailed connections entirely. The automated check was complete, deterministic, and took 2 minutes to run.

Case Study 3: Seismic Frame Review — Class/Framing Mismatch Detection

Project context. A low-rise industrial building in a seismic zone. The lateral system: four moment frames in the N-S direction, steel bracing in the E-W direction. The Tekla model had been through two lateral system revisions during design development. In the first revision, three bays that were moment frames were converted to braced bays. In the second revision, one of those three was converted back to a moment frame.

The connection details were not consistently updated through the revisions. The zone map reflected the final lateral system. The connection components reflected a mixture of all three states.

Result of rule CLX-001 / CLX-002 run. Four class/framing mismatches detected:

• 2 × moment connections in newly-braced bays (CLX-001, CRITICAL).
• 1 × pinned shear tab in the bay that was reinstated as a moment frame (CLX-002, CRITICAL).
• 1 × moment connection in a gravity-only bay adjacent to the moment frame (CLX-001, HIGH — the connection was within 500 mm of the zone boundary, which suggested a possible zone map misclassification rather than a connection error; this was resolved by the structural engineer confirming the zone boundary and accepting the exception with a note).

All four were resolved before IFC release. The two CRITICAL CLX-001 items represented connections that would have transferred moment into columns designed for shear only. The CRITICAL CLX-002 item represented a moment frame column whose beam connection would have provided no moment resistance in a seismic event.

Limits and Caveats

The automation described in this article is a detailing rule filter. It is not a structural analysis and it is not a substitute for engineering calculation. Being explicit about the limits is a professional responsibility.

What this approach does not check:

1. Strength adequacy. All rules in this article are detailing rules that can be evaluated from model geometry and component parameters without applied load data. Connection strength (bolt shear capacity, weld group capacity under combined loading, plate bearing, block shear) requires the connection force and the full design calculation. These checks must be performed by the connection design software (IDEA StatiCa, RAM Connection, or equivalent), not by a model-walking rule engine.

2. Dynamic and seismic connection requirements. AISC 341 (Seismic Provisions for Structural Steel Buildings) imposes connection requirements beyond AISC 360 detailing minimums: expected yield strength adjustments, protected zones, continuity plate requirements, weld toughness specifications. These are not captured by the rules above and require separate, seismic-specific rule development.

3. Welding procedure specification compatibility. The minimum weld size rules confirm that the weld as modelled meets detailing minimums. They do not confirm that the WPS (welding procedure specification) applicable on this project supports the specified weld in the specified position on the specified base material. That is a fabrication-level check.

4. Non-standard and custom connections. Any connection that does not have a Tekla component number in the rule set's lookup tables will not be evaluated by rules that depend on component number classification. Custom connections built as assemblies or modelled with non-catalogued components require separate treatment.

5. Drawing vs. model discrepancy. If the Tekla model and the fabrication drawings have diverged — a not-uncommon condition on fast-tracked projects — the rule engine checks the model. Errors in the drawings that are not reflected in the model will not be caught.

A note on false confidence. The most significant risk in automating connection review is not that the automation misses errors — it is that the project team believes it has checked more than it has. The QA record should explicitly list the rules that were run and those that were not. "Connection review automated" is not a legitimate sign-off statement. "Detailing rule filter run against connection model; 0 CRITICAL, 2 HIGH accepted with engineering rationale; strength adequacy verified by separate design calculation package" is.

Sources and Further Reading

The following sources were used in the preparation of this article and are recommended for practitioners implementing connection review automation.

AISC 360-22 — Specification for Structural Steel Buildings (2022 edition) The current edition of the AISC specification. Table J2.4 (fillet weld minimum sizes) and Section J2.2b (governing thickness and exception) are the primary weld detailing references for US practice. Section J3.4 and Table J3.4 cover bolt spacing and edge distances. AISC Fillet Weld FAQ

AISC Table J2.4 Reference — Steel Calculator Convenient tabular reference for AISC 360-22 Table J2.4 minimum fillet weld sizes with metric conversions. steelcalculator.app/reference/min-weld-size/

EN 1993-1-8:2005 — Eurocode 3: Design of Joints The governing European standard for steel joint design. Section 4 covers welded connections; Sections 4.3.2.1 (fusion face angles), 4.5.2 (minimum throat thickness), and 4.5.3 (weld resistance) are the primary references. Section 3.5 and Table 3.3 cover bolt spacing and edge distances. Dlubal Knowledge Base — EN 1993-1-8 Fillet Weld Design

ASTM F3125 / A325 / A490 — High-Strength Structural Bolts ASTM F3125 is the current unified standard for high-strength structural bolts, incorporating the former A325 and A490 specifications. Key distinction: A490 (Grade F3125-A490) must not be hot-dip galvanized. Portland Bolt — A325 vs A490

ISO 898-1:2013 — Mechanical Properties of Fasteners: Bolts, Screws and Studs The ISO standard defining metric property classes including 8.8 (800 MPa tensile, 640 MPa yield) and 10.9 (1040 MPa tensile, 940 MPa yield). ISO 898-1 Property Class Reference — Vibromera

Tekla Developer Center — Open API Documentation The authoritative reference for the Tekla Open API. Covers Model, ModelObjectSelector, Connection, BoltGroup, Weld, and ModelObjectEnumerator classes. developer.tekla.com

Tekla Developer Center — Model Code Examples C# code examples for creating, modifying, and enumerating model objects including connections and components. Source repository: github.com/TrimbleSolutionsCorporation/TSOpenAPIExamples developer.tekla.com — Model code examples

Tekla User Assistance — Moment Connections and End Plate Connections Reference for Tekla standard connection component numbers, parameters, and descriptions for moment connections (130, 134, 181) and end plate connections (29, 32, 144). support.tekla.com — Moment connections support.tekla.com — End plate connections

IDEA StatiCa — Detailing of Bolts and Welds per AISC Practical reference for AISC detailing rule implementation in connection design software. ideastatica.com/support-center/detailing-of-bolts-and-welds-according-to-aisc

Fillet Weld Design and Check per EN 1993-1-8 — Structolution Interactive reference for EC3 fillet weld design including the directional and simplified methods, throat thickness, and correlation factor tables. structolution.com/calculations/fillet-weld-check

This article reflects practice as of June 2026 using Tekla Structures 2024/2025 and the Tekla Open API against the current editions of AISC 360-22 and EN 1993-1-8:2005. Rule thresholds should be verified against the applicable code edition and any national annex requirements for the specific project jurisdiction. Nothing in this article constitutes engineering design advice for a specific project; all structural decisions remain the responsibility of the engineer of record.