Modeling with structural software and checking results

Every method in this course is now inside the analysis program on an engineer's desk. The program assembles and solves stiffness matrices with thousands of degrees of freedom in seconds, but it does exactly what the model tells it, including the mistakes. The engineer's job has shifted from solving equations to building models that represent the structure faithfully, combining load cases correctly, and proving that the output is right. This lesson walks through those three tasks for the operations center, using the hand methods of lessons 2 to 11 as the checks.

From structure to model

A model represents each member by its centerline and each connection by a node, and it replaces the real supports, connections and loads by idealized ones. CIV-224 lesson 1 introduced these idealizations; in an indeterminate structure they matter more, because the force distribution depends on relative stiffness and on boundary conditions. The main decisions are these.

• Supports. Is the column base pinned, fixed or something in between? A base plate with four anchor rods on a footing that can rotate is closer to a pin than to a fixed support. Lesson 6 showed that the choice changes the sway of the garage frame by a factor of more than four. If in doubt, analyze both bounds, or model the base as a rotational spring.
• Connections. Simple shear connections are modeled with moment releases; moment connections as rigid. A beam that is released at both ends in a model but welded in reality will crack the connection or the slab at its ends, so the detail and the model must agree.
• Member properties. Use gross section properties for steel. For concrete, design standards specify reduced effective stiffnesses for cracked members (beams are typically given a smaller fraction of their gross moment of inertia than columns), and these change the distribution of moments in an indeterminate frame.
• Rigid zones and offsets. Where deep members meet, the joint region is much stiffer than the members, and centerline models overestimate flexibility. Programs allow rigid end offsets for this.
• Diaphragms. A concrete floor slab is very stiff in its own plane and is often modeled as a rigid diaphragm that ties all the nodes of a floor together horizontally, just as the inextensible beam tied the garage corners together.
• Load application. Gravity loads on beams are entered as member loads; wind is applied as nodal forces or as pressures on wall elements; temperature and settlement as imposed strains and support displacements (lesson 4).

Load cases, combinations and envelopes

A model is analyzed once for each load case: dead, live, snow, wind in each direction, temperature, and so on, each with its specified (unfactored) values. Because the analysis is linear, the results for any load combination are the factored sums of the case results. This is far more efficient than analyzing each combination separately, and it lets the program form an envelope: the most positive and most negative value of every response over every combination.

CIV-224 lesson 2 set out the ASCE 7 strength (LRFD) load combinations: \(1.4D\); \(1.2D + 1.6L + 0.5(L_r\ \text{or}\ S\ \text{or}\ R)\); \(1.2D + 1.6(L_r\ \text{or}\ S\ \text{or}\ R) + (L\ \text{or}\ 0.5W)\); \(1.2D + 1.0W + L + 0.5(L_r\ \text{or}\ S\ \text{or}\ R)\); \(0.9D + 1.0W\); and the two seismic combinations. Wind in ASCE 7-22 is a strength-level load, so its factor is 1.0. Where dead load counteracts the effect being checked, as for uplift or overturning, the \(0.9D\) combination governs.

Two points are easy to miss. First, each load that can act in more than one direction (wind from the left or the right, live load on any pattern of spans) multiplies the number of combinations, and the envelope must include all of them. Second, the combination that governs is different at different points: the roof load case controls the corners of the garage frame, but the reduced dead load with full wind controls the reversal of moment at the windward base.

For frames whose sway is significant, the linear superposition used here is only the first step. Second-order effects depend on the total gravity load in each combination, so a second-order analysis must be run combination by combination rather than case by case, or the sway moments amplified for each combination. Both design standards set out when this is required.

Checking the output

An analysis program never reports that it was given the wrong model. Every result that will be used in design should pass a set of checks, and the hand methods of this course provide them.

For the garage frame, statics gives the clearest check. Under the snow combination the roof carries \(0.80(60) = 48.0\) kips, so the two vertical base reactions must total 48.0 kips; under any wind case the horizontal base reactions must total the factored wind. The symmetric snow case must give equal corner moments. The corner moment under the full uniform load must equal \(wL^2/16\) for this frame (lesson 6), or, for a beam of different relative stiffness, a value between the fixed-end moment \(wL^2/12\) and zero.

The office wing comparison in lesson 11 showed that an approximate method can be wrong by a third for some members. That does not mean the check is useless; it means the engineer must understand why the two differ. When a model and a hand check disagree, one of them is wrong or they represent different structures, and finding out which is the most valuable hour of the analysis.

Common modeling errors

Experience across many projects shows the same errors recurring. Units are the classic one: a modulus entered in megapascals where the program expects kilopascals, or kips per square inch where it expects kips per square foot, makes every displacement wrong by a factor of a thousand or 144 while leaving the forces of a determinate structure unchanged, so a statics check alone cannot catch it. Local axis orientation is another: a member with its strong axis rotated 90 degrees has a fraction of its intended stiffness and attracts little moment. Releases are a third: releasing both ends of every beam in a frame meant to be rigid turns it into a mechanism under lateral load, which a good program reports as instability; releasing too few makes the frame stiffer than built. Finally, load patterns: a model that has only all-spans-loaded live load misses the pattern effects of lesson 2.

Sharing the work

Kestrel Bay's practice is that every model has an independent check before its results are used. Priya reviews the model input line by line against the drawings, Owen prepares hand checks of key members using the methods of this course, and Sofia's small programs, like those in these lessons, give a second, transparent calculation for the critical frames. The model, the checks and the reasons for any differences are kept together in the calculation package, so that anyone reviewing the design later can follow the reasoning. A design is only as reliable as the least-checked assumption in it.

Solving it in code

The program forms every combination from the unit-case results, with wind in both directions, and builds the envelope at the four critical sections. It ends with a statics check on the unit wind case.

# Load combinations and envelope for the garage end frame (ASCE 7 strength combinations)
# Unit-case results come from one linear analysis per load case (the lesson 11 program).
# Sign: negative = tension on the outside face of the frame.
h = 20.0                             # column height (ft)
unit = [  # location, moment per kip/ft of roof load, moment per kip of wind to the right (kip*ft)
    ("corner B", -225.0, +4.0),
    ("corner C", -225.0, -4.0),
    ("base A", +112.5, -6.0),
    ("base D", +112.5, +6.0),
]
D, S, W = 0.20, 0.35, 4.5            # nominal dead (kip/ft), snow (kip/ft), strength-level wind (kips)
combos = [  # case, factor on D, factor on S, factor on W (wind can act either way)
    ("1  1.4D", 1.4, 0.0, 0.0),
    ("2  1.2D + 0.5S", 1.2, 0.5, 0.0),
    ("3  1.2D + 1.6S + 0.5W", 1.2, 1.6, 0.5),
    ("4  1.2D + 1.0W + 0.5S", 1.2, 0.5, 1.0),
    ("5  0.9D + 1.0W", 0.9, 0.0, 1.0),
]
print("%-34s" % "combination" + "".join("%10s" % u[0] for u in unit))
env_max = [-1e9] * len(unit); env_min = [1e9] * len(unit)
for name, fd, fs, fw in combos:
    for sign in ((1, -1) if fw else (1,)):
        roof = fd * D + fs * S
        vals = [roof * gm + sign * fw * W * wm for _, gm, wm in unit]
        env_max = [max(a, b) for a, b in zip(env_max, vals)]
        env_min = [min(a, b) for a, b in zip(env_min, vals)]
        label = name + ((", W right" if sign > 0 else ", W left") if fw else "")
        print("%-34s" % label + "".join("%10.1f" % v for v in vals))
print("%-34s" % "envelope, most positive" + "".join("%10.1f" % v for v in env_max))
print("%-34s" % "envelope, most negative" + "".join("%10.1f" % v for v in env_min))
# check the unit wind case: the two column shears must add up to the 1 kip applied
shear = (abs(unit[0][2]) + abs(unit[2][2])) / h + (abs(unit[1][2]) + abs(unit[3][2])) / h
print("check: column shears under 1 kip of wind add to %.2f kips" % shear)

combination                         corner B  corner C    base A    base D
1  1.4D                                -63.0     -63.0      31.5      31.5
2  1.2D + 0.5S                         -93.4     -93.4      46.7      46.7
3  1.2D + 1.6S + 0.5W, W right        -171.0    -189.0      76.5     103.5
3  1.2D + 1.6S + 0.5W, W left         -189.0    -171.0     103.5      76.5
4  1.2D + 1.0W + 0.5S, W right         -75.4    -111.4      19.7      73.7
4  1.2D + 1.0W + 0.5S, W left         -111.4     -75.4      73.7      19.7
5  0.9D + 1.0W, W right                -22.5     -58.5      -6.7      47.2
5  0.9D + 1.0W, W left                 -58.5     -22.5      47.2      -6.7
envelope, most positive                -22.5     -22.5     103.5     103.5
envelope, most negative               -189.0    -189.0      -6.7      -6.7
check: column shears under 1 kip of wind add to 1.00 kips

Each row is a factored sum, so adding a load case (a roof live load, a crane load, a temperature case) is a matter of one more column in the unit table and one more factor in each combination. That is precisely how analysis programs organize their combinations, and why understanding superposition matters even when the computer does the arithmetic.