SutranetTower — User Manual

1.Introduction

SutranetTower is a web application by Sutranet for designing lattice telecom towers — either a 3-leg (equilateral-triangular) or 4-leg (square) cross-section, selected under Tower Type. You describe the tower’s geometry, member sizes, bracing, wind environment and antenna loads in a structured form (or as a JSON file), and the app:

1. Computes wind loads on every section per IS 875 Part 3:2015.
2. Builds the real 3D lattice (legs, diagonals, horizontals) and solves it with OpenSeesPy, a finite-element engine.
3. Checks every member against tension and compression (buckling) capacity per IS 17740:2022 / IS 800:2007.
4. Produces a single self-contained HTML report you can open, share, or archive — and, optionally, a STAAD.Pro .std file for independent cross-checking.

2.Key Concepts

3.Quick Start

1. Open the app at www.sutranet.co.in. Click Load Example to start from a working 40 m tower instead of a blank one.
2. In the Tower Builder tab, walk the left-hand tree: click Wind to set basic wind speed and terrain; click each Slope / Section to set geometry, bracing and member sizes.
3. (Optional) Click the ✦ Review Inputs button to get an automated sanity check before you spend time waiting on the solve.
4. Click Run Analysis. The app polls progress every 1.5 s until the job finishes (typically seconds to low minutes, hard-capped at 180 s — see Limitations).
5. Review the report in the Result tab: start with Summary for the headline max utilisation and drift, then drill into Capacity and Lattice Forces for any overstressed members.
6. Use Export JSON to save your tower definition, and (optionally) download the STAAD .std file for an independent cross-check.

4.Wind Input

Wind loading follows IS 875 Part 3:2015. The design wind speed at any height is:

Vz = Vb × k1 × k2 × k3 × k4
pz = 0.6 × Vz²   (design wind pressure, N/m²)

Wind speed lookup by location

Click the map/lat-lon field in the Wind panel to auto-fill basic wind speed from data/windmap.geojson and nearest-coast distance from data/coastline.geojson.

How force coefficients are applied

The Cf table used depends on both the member shape and the tower type (IS 875 Cl. 7.4.3.5):

• Flat-sided (angle) members use Table 33: Cf depends on solidity ratio φ. On a 3-leg tower it is constant for all wind directions; on a 4-leg (square) tower the face→corner increase (Cl. 7.4.3.5(b), 1.0→1.2×) is interpolated linearly by wind angle.
• Round (pipe) members use Table 35 on a 3-leg tower and Table 34 (face vs. corner Cf) on a 4-leg tower. Cf depends on solidity ratio φ and flow regime, set by D×Vz (DVd): below 6 m²/s the flow is subcritical (higher Cf, ~1.3–1.8); at/above 6 m²/s it is supercritical (lower Cf, ~0.8–1.2).
• Solidity ratio φ is computed per section from the actual projected member areas vs. the gross panel face area — you don’t set φ directly, it falls out of your member sizing.

5.Slopes & Sections

Build the tower top-down or bottom-up in the tree: add Slopes for each taper change, then one or more Sections inside each slope.

6.Member Sections

Each section needs a leg_section, diagonal_section and (optionally) horizontal_section (horizontal), plus any redundant_sections needed by the chosen bracing pattern. Two section types are supported:

Pipe (circular hollow section)

Angle (equal-leg, IS 808:2021)

Double angle

Same fields as Angle, plus gap_mm (back-to-back spacing, default 10 mm), which shifts the combined Iyy via the parallel-axis theorem.

Bolt holes & net section

Set n_bolt_holes and bolt_hole_dia_mm on any member to have its net-section tensile capacity (Tdn, IS 800 Cl. 6.3.1) reduced accordingly. fu (ultimate strength) is derived automatically from fy via the IS 2062 grade mapping (e.g. fy = 250 → fu = 410 MPa) — you do not set fu directly.

Connection design (optional)

Each section can carry a bolted-connection check, enabled by the Connection design toggle on that section in the Tower Builder. The spec is edited as a small raw-JSON block; leave a sub-key out to skip that connection. The checks are driven by the factored axial demand that the section’s members actually attract in the analysis (tension for the flange, axial magnitude for bracing), and every result appears in the report’s Connections tab. All checks use IS 800:2007 partial safety factors: γ_m0 = 1.10, γ_m1 = 1.25, γ_mb = 1.25 (bolts), γ_mw = 1.25 (shop weld).

Bolted shear connections — what each field measures

Applies to diag_bracing, horiz_bracing, redundant_bracing and leg_splice — they all share one field set. All dimensions are in millimetres, strengths in MPa.

Ring-flange leg splice — what each field measures

Applies to flange, used when the leg is a pipe (CHS).

Detailing (IS 800 §10.2). Every bolted-shear spec is also checked against the spacing limits the capacity equations assume: minimum end and edge distance (Cl. 10.2.4.2), maximum edge distance 12·t·ε (Cl. 10.2.4.3), and minimum pitch 2.5·d (Cl. 10.2.2). The minimum end/edge distance depends on how the edge was prepared, so edge_type is required and has no default — "sheared" / "hand_flame_cut" give 1.7× the hole diameter, "rolled" / "machine_flame_cut" / "sawn" / "planed" give 1.5×. Omitting it reports the distance as unchecked rather than assuming a factor; an unrecognised value is an error. A detailing violation fails the connection but does not appear in its utilisation ratio, which stays a pure strength figure. Note the Cl. 10.2.3.1 maximum pitch and the corrosive-exposure edge cap are not checked.

JSON schema

The connections object sits on a section, alongside leg_section / diagonal_section / redundant_sections. Every sub-key is optional — omit one to skip that connection entirely. Notation below: (required) means the analysis raises if the key is absent; = value is the default applied when it is.

"connections": {                    // optional, per section

  "flange": {                      // leg splice — PIPE (CHS) leg only
    "n_bolts":          integer (required)   // bolts on the pitch circle
    "d_bolt":           number  (required)   // mm
    "pcd":              number  (required)   // mm, bolt pitch-circle DIAMETER
    "plate_thickness":  number  (required)   // mm
    "plate_od":         number  (required)   // mm, plate outside DIAMETER
    "plate_fy":         number  = 250        // MPa
    "plate_fu":         number  = from plate_fy
    "fub_bolt":         number  = 800        // MPa (grade 8.8)
    "fyb_bolt":         number  = 640        // MPa
    "pretensioned":     boolean = false      // sets β in Cl. 10.4.7 prying
    "weld_throat":      number  = 0          // mm; 0 ⇒ full pen, weld check SKIPPED
    "fu_weld":          number  = 410        // MPa
    "fu_pipe":          number  = from the leg grade
  },                                          // pipe OD/thk/fy come from leg_section

  "leg_splice": {                  // leg splice — ANGLE / DOUBLE-ANGLE leg only
    // …all the bolted-shear fields below, plus:
    "bearing_credit":   boolean = false      // true ⇒ halve compressive demand (§10.8)
    "t_ply":            number  = 8.0        // NOTE: 6.4 for the bracing blocks
  },

  "diag_bracing":  { …bolted-shear fields… },   // diagonals
  "horiz_bracing": { …bolted-shear fields… },   // horizontals

  "redundant_bracing":                 // EITHER one shared spec…
      { …bolted-shear fields… }
    // …OR one spec per redundant tag, keyed as in "redundant_sections":
    { "r1": { …fields… }, "r2": { …fields… } }
}

// ── bolted-shear fields (diag_bracing, horiz_bracing,
//    redundant_bracing and leg_splice all share these) ──
    "d_bolt":           number  (required)   // mm
    "d_hole":           number  (required)   // mm, = d_bolt + clearance
    "edge_type":        string  (required if end_dist/edge_dist given)
                                             // "sheared" | "hand_flame_cut"
                                             // "rolled" | "machine_flame_cut" | "sawn" | "planed"
    "fub_bolt":         number  = 800        // MPa
    "n_shear_planes":   integer = 2          // 1 = single lap ← usual for redundants
    "threads_in_plane": boolean = true       // false ⇒ shank area, not 0.78·A
    "t_ply":            number  = 6.4        // mm, governing thickness in bearing
    "fy_ply":           number  = 250        // MPa
    "fu_ply":           number  = from fy_ply
    "width_gross":      number  = 0          // mm; 0 ⇒ net-section check SKIPPED
    "end_dist":         number  = 0          // mm; 0 ⇒ inflates bearing k_b
    "edge_dist":        number  = 0          // mm
    "pitch":            number  = 0          // mm, between bolts in line of force
    "n_bolts_line":     integer = 1          // bolts in the line of force

fu is never set directly — it is derived from fy through the IS 2062 grade map (250→410, 300→440, 310→450, 350→490 MPa; anything else → 410).

A complete example

An angle-leg section with per-tag redundant detailing — r1 on M16 and the more heavily loaded r2 on M20:

"connections": {
  "leg_splice": {
    "d_bolt": 20.0, "d_hole": 22.0, "fub_bolt": 800.0,
    "n_shear_planes": 2,            // cover plate each side of the angle
    "t_ply": 8.0, "fy_ply": 250.0, "width_gross": 70.0,
    "end_dist": 40.0, "edge_dist": 38.0, "edge_type": "sheared",
    "pitch": 60.0, "n_bolts_line": 2,
    "bearing_credit": true          // IS 800 §10.8 full-contact bearing
  },
  "diag_bracing": {
    "d_bolt": 20.0, "d_hole": 22.0, "fub_bolt": 800.0,
    "n_shear_planes": 1,            // single lap onto the gusset
    "t_ply": 8.0, "fy_ply": 250.0, "width_gross": 70.0,
    "end_dist": 40.0, "edge_dist": 38.0, "edge_type": "sheared"
  },
  "redundant_bracing": {            // keys match "redundant_sections"
    "r1": {
      "d_bolt": 16.0, "d_hole": 18.0, "fub_bolt": 800.0, "n_shear_planes": 1,
      "t_ply": 6.0, "fy_ply": 250.0, "width_gross": 50.0,
      "end_dist": 32.0, "edge_dist": 32.0, "edge_type": "sheared"
    },
    "r2": {
      "d_bolt": 20.0, "d_hole": 22.0, "fub_bolt": 800.0, "n_shear_planes": 1,
      "t_ply": 8.0, "fy_ply": 250.0, "width_gross": 70.0,
      "end_dist": 45.0, "edge_dist": 38.0, "edge_type": "sheared"
    }
  }
}

The // comments are for this manual only — strip them, JSON has no comments. A single flat spec is still accepted in place of the {"r1": …, "r2": …} map when every redundant tag shares one detail. Swap leg_splice for flange if the leg is a pipe.

7.Bracing Patterns

Pick a bracing pattern per section from the dropdown (built from the editable bracings.json library). Every face automatically receives the same pattern by rotational symmetry (120° on a 3-leg tower, 90° on a 4-leg tower). Each pattern declares which leg counts it is valid for (applicable_legs) — the dropdown only offers patterns valid for the current Tower Type, and picking an incompatible one is rejected at run time with a clear error.

The shipped library is a deliberately small starter set of four standard patterns. Anything beyond these is user-defined: create your own in the Bracing Library editor and they are saved to your private library (they never modify the shipped set).

Plan bracing (4-leg towers)

A triangular ring is inherently rigid, but a square ring is not — so even-leg (4-leg) towers often need plan bracing: horizontal diagonals across the ring that provide torsional/plan rigidity and also shorten the out-of-plane buckling length of crossover X-braces. In the library editor these appear as Plan Bracing (opposite-face links) alongside the legacy Hip Members (adjacent-face links); both are saved into each pattern’s redundant_links.

The Bracing Library editor

The Bracing Library tab is a single unified 3D editor — you author directly on the live 3D lattice (it replaces the older 2D Face Canvas / Hip / Plan views and the read-only preview). You still design one face — whatever you draw on the reference face is replicated to every other face automatically by rotational symmetry, so a pattern stays leg-count-agnostic. The tab has three regions plus two assistants:

• Pattern list (left) — every pattern with a small 2D thumbnail; + New, Clone, Delete. The list is filtered to patterns valid for the current Tower Type.
• 3D Pattern Editor (centre) — the interactive viewport: drag to rotate, scroll to zoom. Each face carries the fixed corner nodes bot_L, bot_R, top_L, top_R, and faces are labelled F0, F1…. You author by clicking one node then another: two nodes on the same face draw a same-face member; two nodes on different faces draw a cross-face (hip / plan) link with the face offset inferred automatically — there is no separate Hip/Plan mode. Click an existing member or cross-face line to split it with a node. A colour legend below the viewport keys diagonal / redundant / ring / cross-face / leg.
• Editing & controls (right) — the context panels that appear for the current action (draw-member / add-node, member type & OPS element, cross-face link tag, rings and redundant-link lists), plus the two assistants below.
• Pattern Health panel — four live checks (no duplicate members, all nodes connected, no bypassed nodes, all nodes have out-of-plane stiffness) that update as you edit. Fix reds before saving.
• Guidance panel — a rule-based (or AI-backed, if an API key is configured) helper. Click Explain current errors or ask a free-text question about the pattern.

Anatomy of a pattern

A pattern is a small record (stored in bracings.json) built from these pieces:

Step-by-step: creating a custom pattern

1. Open the Bracing Library tab. Start from an existing pattern close to what you want (select it, then edit) rather than a blank face — it’s faster and less error-prone.
2. Set the Tower Type you’re targeting in the Tower Builder first, so the 3D editor shows the correct 3-leg or 4-leg lattice while you work.
3. Place nodes. In the 3D viewport click two existing nodes on the same face; in the panel that appears, drag Position t and click Add Node to drop a node at that fraction along the line between them. For a true X crossing, click ✕ X-intersect Node and then click the four endpoints of the two crossing lines — the app computes their intersection.
4. Draw members. Click one node, then another on the same face; choose Diagonal, Horizontal or Redundant. Click an existing member to change its Type, its OPS element, or (for redundants) its Tag, or to remove it.
5. Split, don’t bypass. If a node sits partway along a member’s path, that member must be drawn as two segments meeting at the node — never as one member that runs past it (see Do’s & Don’ts). Click a member (or a cross-face line) to split it at a node.
6. (4-leg / stiffening) Add cross-face links in the same viewport: click a node on one face, then a node on a different face — the editor makes a Hip (adjacent face) or Plan-bracing (opposite face) link and infers the face offset automatically. Give it a Tag and Save Link. For a full horizontal ring, click the same node label on two adjacent faces and choose ＋ Horizontal ring. Use the F0, F1… face labels to pick the intended adjacent/opposite face deliberately.
7. Watch the Pattern Health panel. Resolve every red item; use Explain current errors for a plain-language fix.
8. Open Pattern Settings & Save: set Name, Aliases, Description, and tick the Applies to (3-leg / 4-leg) boxes. Click Save Pattern (local).
9. Save to server (built-in library for admins, or my patterns for a private copy). The server re-validates with validate_bracing_pattern() and rejects anything invalid. This step is required before the pattern can be used in an analysis.
10. Assign the pattern to a section in the Tower Builder, and give that section a redundant_section for each redundant Tag you used (or enable Auto-Size).

Do’s and Don’ts

8.Antennas & Ladder/Cable Tray

Antennas

Add one or more antenna entries with an elevation_m, a type (panel / dish / generic), and one or more mounted instances (mount index, radial offset_m from the tower centreline, and azimuth_deg). Each instance contributes projected wind area, drag, dead weight and an associated torsional moment to the global load vector at its elevation.

Ladder / cable tray

Toggle this on to add a continuous vertical appurtenance, defined by effective drag area per metre (A_eff_m2_per_m), its location (outside_face, inside_face, or inside_axis), and the elevation range it covers.

9.Analysis Config

The Config node sets the load-combination standard (IS 800:2007 Table 4 or IS 17740:2022 Table 2) and the redundant-member steel grade (IS 2062). When Auto-Size is enabled, a redundant with no explicit section is sized automatically (IS 1161 / IS 808); otherwise a section is required and the run errors rather than silently borrowing the diagonal size.

The element formulation for each diagonal and horizontal is defined per member in the Bracing Library — every pattern carries its own ops_element (choose corotTruss, Truss, or elasticBeamColumn on each member), so different sections can use different bracing behaviour. It is no longer a single tower-wide toggle in the Config node.

Legs always use elasticBeamColumn (they carry significant bending in addition to axial load and need full beam behaviour). For model-validation work, the per-member choice can be force-overridden from the CLI (not exposed in the UI):

python main.py tower.json --diag-type elasticBeamColumn --horizontal-type elasticBeamColumn --redundant-grade 350

Automatic planar-joint stabilization. Singular “planar-joint” nodes (for example an X/M crossover on a square 4-leg face with no plan bracing) have no out-of-plane stiffness when their bracing is axial-only truss, which would make the stiffness matrix singular. SutranetTower auto-stabilizes these joints — the offending truss bracing is promoted to elasticBeamColumn automatically (the PLS-TOWER / tnxTower approach), so the model stays solvable without manual edits. This is on by default; the analysis log lists exactly which joints were stabilized.

Dynamic wind, seismic & ice loads

Three additional IS 17740 load effects live under the Ice & Seismic Loads builder node. All three are opt-in and off by default — a plain tower report is unchanged unless you deliberately enable them.

When enabled, the member-capacity check envelopes over all ultimate cases (wind + seismic + ice), and the report Summary tab gains dedicated dynamic / seismic / ice panels. A red banner also appears whenever f₁ < 1.0 Hz to flag that a dynamic gust-factor analysis is required.

10.Running the Analysis

1. Click Run Analysis. The browser posts your tower JSON plus the analysis config to the server, which spawns the analysis as a background job and returns a job_id.
2. The app polls job status every 1.5 s. Status moves through running → done or error.
3. On done, the generated HTML report loads automatically into the Result tab.
4. On error, the status panel shows the parsed error summary (e.g. validation failure, timeout, or memory limit — see Troubleshooting).

11.AI / Rule-Based Guidance

Two optional “✦” guidance buttons are available, both backed by Claude (claude-haiku-4-5) when an API key is configured on the server, and by a deterministic rule-based engine otherwise — you get useful feedback either way.

Bracing pattern guidance

While editing a custom bracing pattern, get instant feedback on duplicate members, floating nodes, and bypassed nodes, with suggested fixes.

Tower / results guidance

• Before running (“Review Inputs”): flags widening-with-height geometry, panel heights below 1 m or above 6 m, very thin-walled members (D/t > 50), wind speeds outside a plausible 25–75 m/s range, and antenna/ladder elevations outside the tower height.
• After running (“Explain Results”): flags max UC > 1.0 (overstressed) or > 0.9 (marginal), drift exceeding the IS 17740:2022 Cl. 10.1.2 limits (3% of height sway, 4° twist), KL/r above the per-role IS 17740 limits (legs/diagonals 150, horizontals 200, redundants 250), and identifies the governing wind direction, with suggested next steps (e.g. “increase OD×t of section S3 leg”).

12.Reading the Report

The 3D viewer in the Geometry tab also has Deflected shape and Force colours toggles that redraw the real lattice at its displaced position (scaled) and colour members by force for the selected wind direction.

Utilisation ratio (UC)

UC = |Applied Force| / Governing Capacity

• Tension: governing capacity = min(gross-section yield Tdg, net-section rupture Tdn if bolted)
• Compression: governing capacity = Perry–Robertson buckling capacity per IS 800 Cl. 7.1, γ_m0 = 1.10, using buckling curve ‘a’ (α = 0.21) for CHS/pipe and curve ‘c’ (α = 0.49) for angle / double-angle sections (IS 800 Table 10). Bracing members additionally use the IS 17740 Annex F equivalent slenderness.

Tension and compression envelopes are tracked separately per member/section, so a larger tension force can never mask a smaller-but-governing compression case.

Pass/Fail

A member passes when UC ≤ 1.0 and its KL/r is within the per-role limit (IS 17740 Annex E-4 / Annex F Note 7: legs & diagonals 150, horizontals 200, redundants 250). Tip drift vs the IS 17740:2022 Cl. 10.1.2 limits (3% of height; 4° rotation) is a serviceability flag, not a strength criterion, but should not be ignored.

13.STAAD.Pro Export

Download a STAAD.Pro .std file rebuilt from your stored tower JSON, for independent cross-checking or detailed design continuation.

• Coordinate system: Z-up; units: METER, KN, °C
• All lattice nodes (legs, diagonals, extra/redundant nodes, antenna points) and members, mapped to MEMBER TRUSS (pin-ended, axial only) for corotTruss/Truss elements, or full BEAM elements (with section properties AX, IZ, IY, IX, AY, AZ) for elasticBeamColumn
• Material: E = 200000 MPa, ν = 0.30, ρ = 7850 kg/m³
• Load cases: LC1 dead load (self-weight + antenna & ladder dead weight), LC2 live/maintenance load (apex maintenance load plus the IS 17740 Cl. 7.2.2 ladder climber load where a ladder is defined), LC3+ wind per direction (including per-direction ladder wind); combinations per the selected standard (IS 800:2007 Table 4 or IS 17740:2022 Table 2)

14.Accounts & Quota

If the deployment has Firebase authentication configured, you’ll see a sign-in modal on first visit. Each account has a role (free or admin) and a monthly run quota that resets on the 1st of each month; your remaining quota is shown next to your email in the header. Admins can adjust other users’ quotas.

Ways to sign in

Forgot your password?

On the Sign In tab, click Forgot password?, enter your account email, and click Send reset link. Firebase emails you a secure link to choose a new password — check your inbox (and spam folder). For privacy the app shows the same confirmation whether or not that email is registered, so the message appearing does not by itself confirm an account exists. Password recovery applies to email/password accounts; if you signed up with Google, sign in with the Continue with Google button instead (your password is managed by Google).

15.Limitations

16.Best Practices

• Start from the example tower and modify incrementally rather than building from a blank slate — it’s a known-valid baseline.
• Run “Review Inputs” before every analysis, especially after large geometry or bracing changes — it catches common modelling mistakes for free.
• Check the Geometry tab first after every run, before trusting any numbers — a wrong bracing pattern or panel count produces a structurally different (and silently wrong) model.
• Keep panel heights moderate (roughly 1–6 m) — very short or very tall panels distort solidity ratio and force-coefficient assumptions.
• Use more/shorter sections at the base, where wind moment and axial load are highest, and fewer/taller sections near the top.
• Cross-check critical designs against the STAAD export, particularly when UC is close to 1.0 or when you’ve switched diagonals to elasticBeamColumn.
• Export your tower JSON after every meaningful change — there is no persistent history without Firebase, and a server restart silently discards in-memory jobs.
• Validate custom bracing patterns in the Bracing Library tab before using them in a real tower — fix any duplicate-member, floating-node, or bypassed-node errors immediately.
• Treat AI/rule-based guidance as a second opinion, not a final verdict — always apply engineering judgement on top of it.

17.Troubleshooting

18.Glossary

Bracing editor & geometry

These are the terms used inside the Bracing Library editor and the pattern schema (bracings.json). A pattern is always authored on one face and replicated to every face by rotational symmetry, so most terms describe a single face and how members reach across to their neighbours.

Analysis & code