8.14  Truss analysis

Counting rods and equations

Whether equilibrium alone fixes the rod forces can be decided by counting, before any joint is cut free. Each pinned joint gives two equilibrium equations, one in \(x\) and one in \(y\), so a plane truss with \(j\) joints has \(2j\) equations. The unknowns are the \(m\) rod forces and the \(r\) support reactions, two at a pin support and one at a roller. Comparing the two counts gives three cases,

\[ m + r \;\begin{cases} < 2j & \text{a mechanism}\\ = 2j & \text{statically determinate}\\ > 2j & \text{statically indeterminate} \end{cases} \tag{8.14.1}\]

and in the last case the surplus \(m + r - 2j\) is the degree of static indeterminacy, the number of compatibility conditions that must be added to equilibrium before the rod forces can be found.

Figure 8.14.3 applies the count to a square on a pin and a roller, with \(j = 4\) joints, \(r = 3\) reactions and therefore \(2j = 8\) equations. Without a diagonal, (a) has seven unknowns for eight equations. One equation cannot be met for a general load, and the square folds into a parallelogram. One diagonal, (b), splits the square into two triangles, the smallest arrangement that keeps it rigid, and the eight unknowns follow from the eight equations. A second diagonal, (c), adds a ninth unknown. The load now has two paths across the square, and how it divides between the two diagonals depends on their stiffnesses \(EA/L\), which equilibrium does not contain. The three-rod truss of Example 1 below counts the same way: \(j = 4\), \(m = 3\) and \(r = 6\), since nodes 2, 3 and 4 are pinned, so \(m + r = 9 > 8\) and it is once statically indeterminate.

The count is necessary but not sufficient. It says whether there are enough rods and reactions, not whether they sit in the right places. Turn the roller of (b) so that it pushes horizontally: the count is still eight, but all three reactions now pass through the pin at node 1, nothing resists a rotation about it, and the truss is a mechanism. The geometric check is to build the truss from triangles. Start from one triangle and attach each new joint with two rods that are not in line, and support the whole on reactions that neither meet in one point nor are all parallel. A truss built that way and passing 8.14.1 is statically determinate.

Building A by unit displacements

Read 8.14.3 column by column. Setting \(\bm u = [1, 0]^\mathsf{T}\) gives \(\bm\delta\) equal to the first column of \(\bm A\), and \(\bm u = [0, 1]^\mathsf{T}\) gives the second. Each column is therefore the set of rod deformations produced by moving the free node one unit in one coordinate direction, which is something we can read straight off a deformation figure.

The small-deformation assumption is what makes this legitimate. Because the displacements are infinitesimal compared with the rod lengths, each rod may be treated as merely translated, staying parallel to its original direction, and its deformation is the projection of the nodal displacement onto its own axis.

Moving node 1 one unit in \(x\), as in Figure 8.14.8, stretches rod 1 by its full length, stretches rod 2 by the projection \(\cos 45^\circ = 1/\sqrt2\), and does nothing to the vertical rod 3,

\[ \delta_1^x = 1, \qquad \delta_2^x = \cos 45^\circ = \frac{1}{\sqrt2}, \qquad \delta_3^x = 0 \]

Moving it one unit in \(y\), as in Figure 8.14.9, leaves the horizontal rod 1 unchanged, stretches rod 2 by \(\sin 45^\circ\) and stretches rod 3 by its full length,

\[ \delta_1^y = 0, \qquad \delta_2^y = \sin 45^\circ = \frac{1}{\sqrt2}, \qquad \delta_3^y = 1 \]

Every entry here is positive because moving the joint upwards pulls on both of the rods that hang below it. Signs do matter, and they will appear as soon as the load is applied downwards. Assembling the two columns,

\[ \bm A = \begin{bmatrix} \delta_1^x & \delta_1^y\\ \delta_2^x & \delta_2^y\\ \delta_3^x & \delta_3^y \end{bmatrix} = \begin{bmatrix} 1 & 0\\[4pt] \dfrac{1}{\sqrt2} & \dfrac{1}{\sqrt2}\\[6pt] 0 & 1 \end{bmatrix} \tag{8.14.7}\]

and note that not one material property or cross-sectional area appears in it. The matrix \(\bm A\) is purely geometric.

Building the same matrix by joint equilibrium

The alternative route reads 8.14.5 instead, and it is the classical method of joints. Isolate node 1 and write force equilibrium in the two coordinate directions, with the rod forces drawn positive in tension so that each pulls the joint towards the far end of its rod.

\[ \begin{array}{l} \rightarrow:\; f_1^x - N_1 - N_2\cos 45^\circ = 0\\[4pt] \uparrow:\; f_1^y - N_3 - N_2\sin 45^\circ = 0 \end{array} \qquad\Longrightarrow\qquad \begin{array}{l} f_1^x = N_1 + \dfrac{1}{\sqrt2}N_2\\[6pt] f_1^y = \dfrac{1}{\sqrt2}N_2 + N_3 \end{array} \]

which in matrix form is

\[ \begin{bmatrix} f_1^x \\ f_1^y \end{bmatrix} = \underbrace{\begin{bmatrix} 1 & \dfrac{1}{\sqrt2} & 0\\[6pt] 0 & \dfrac{1}{\sqrt2} & 1 \end{bmatrix}}_{\bm A^\mathsf{T}} \begin{bmatrix} N_1 \\ N_2 \\ N_3 \end{bmatrix} \]

and is the transpose of 8.14.7, as the energy argument promised. Use whichever construction you find less error prone and transpose it.

Assembling and solving

The material matrix is diagonal, with entries \(E_iA_i/L_i\) from 8.14.2. With \(E_i = E\), \(A_i = A\), \(L_1 = L_3 = L\) and \(L_2 = \sqrt2 L\),

\[ \bm K^e = \frac{EA}{L}\begin{bmatrix} 1 & 0 & 0\\ 0 & \tfrac{1}{\sqrt2} & 0\\ 0 & 0 & 1 \end{bmatrix} \]

E, A, L, P = sp.symbols('E A L P', positive=True)

r2 = sp.sqrt(2)

A_mat = sp.Matrix([[1,     0],
                   [1/r2,  1/r2],
                   [0,     1]])

K_e = (E*A/L) * sp.diag(1, 1/r2, 1)

K = sp.simplify(A_mat.T * K_e * A_mat)
ltx(r"\bm A &=", A_mat, r",\quad \bm K^e =", K_e,
    r"\\ \bm K &= \bm A^\mathsf{T} \bm K^e \bm A =", K, aligned=True)

The structural stiffness matrix is symmetric, as 8.14.6 requires, and its diagonal entries are equal here because the structure happens to be symmetric about the diagonal rod. The off-diagonal entries are positive and equal. Holding the node against moving in \(y\) while pushing it one unit in \(x\) would take a force \(\sqrt2/4\) upwards, so left to itself the node settles downwards as it is pushed sideways, a coupling supplied entirely by the diagonal rod.

Applying a downward load of magnitude \(P\) to the free node, \(\bm f = [0, -P]^\mathsf{T}\), and inverting gives its displacement.

f_vec = sp.Matrix([0, -P])

u_vec = sp.simplify(K.LUsolve(f_vec))
N_vec = sp.simplify(K_e * A_mat * u_vec)
d_vec = sp.simplify(A_mat * u_vec)

ltx(r"\bm u &=", u_vec, r"= \frac{PL}{EA}", sp.nsimplify(u_vec/(P*L/(E*A))).evalf(4),
    r"\\ \bm N &=", sp.nsimplify(N_vec/P).evalf(4), r"\,P", aligned=True)

The node moves \(0.79\,PL/EA\) along the load and \(0.21\,PL/EA\) across it, so it does not travel in the direction it is pushed. Of the three rods, only rod 1 ends up in tension; rods 2 and 3 are in compression, with rod 3 carrying by far the most at \(0.79P\). That distribution is worth pausing on, because it is not what a first glance suggests. The load is vertical and rod 3 is the vertical rod, so it takes the largest share, but the diagonal rod still picks up more than a third of it and the horizontal rod is loaded despite being perpendicular to the applied force. Every member participates, because they all share one joint whose displacement they all feel.

The stresses and strains follow immediately.

sigma_vec = sp.simplify(N_vec/A)
L_vec = sp.Matrix([L, r2*L, L])
eps_vec = sp.simplify(sp.Matrix([d_vec[i]/L_vec[i] for i in range(3)]))

ltx(r"\bm\delta &=", sp.nsimplify(d_vec/(P*L/(E*A))).evalf(4), r"\,\frac{PL}{EA}",
    r"\\ \bm\sigma &=", sp.nsimplify(sigma_vec/(P/A)).evalf(4), r"\,\frac{P}{A}",
    r"\\ \bm\varepsilon &=", sp.nsimplify(eps_vec/(P/(E*A))).evalf(4), r"\,\frac{P}{EA}", aligned=True)

Seeing the result

Setting \(E = A = L = P = 1\) turns the symbols into numbers we can draw. Figure 8.14.11 puts node 1 where the load takes it, at a quarter of the displacement the numbers give, since a joint that moves most of a rod length is far outside the small movements the method assumes.

num = {E: 1, A: 1, L: 1, P: 1}


def numeric(column):
    """A symbolic column as plain floats, with every symbol set to one."""
    return np.array([float(v.subs(num)) for v in column])


def result_figure(nodes, elements, presc, U, scale, values, label, fmt, **kwargs):
    """The deformed truss coloured by one member quantity, every bar labelled."""
    fig, ax = plt.subplots(figsize=(5.8, 4.4))
    draw_truss(nodes, elements, presc=presc, displacements=U, scale=scale,
               values=values, value_label=label, cmap="jet",
               element_numbers=False, ax=ax, **kwargs)
    moved = nodes + scale*U
    for k, (i, j) in enumerate(elements):
        ax.text(*(moved[i-1] + moved[j-1])/2, fmt.format(values[k]), fontsize=8,
                ha="center", va="center",
                bbox=dict(boxstyle="square,pad=0.2", facecolor="w", edgecolor="none"))


nodes1 = np.array([[1, 1], [0, 1], [0, 0], [1, 0]], dtype=float)  # row i is node i
elements1 = np.array([[2, 1], [3, 1], [4, 1]])       # rod k runs from node k+1 to node 1
presc1 = [3, 4, 5, 6, 7, 8]        # nodes 2, 3 and 4 are pinned: both dofs of each
walls = {2: -90, 3: -90}           # two of the pins hang off a wall, not off the ground
U1 = np.zeros((4, 2))
U1[0] = numeric(u_vec)

Code

fig1 = plt.figure(figsize=(4.2, 5.2))
ax1 = fig1.add_axes([0, 0, 1, 0.94])     # the axes fill the frame, the title sits above

anim1 = animate_truss(nodes1, elements1, U1, presc=presc1, loads=[[1, 0, -1]],
                      support_angles=walls, load_length=0.25,
                      scale_max=0.25, frames=20, ax=ax1,
                      title="deformation scale {scale:.2f}")
to_responsive_html(anim1, container_id="truss-ex1-deformation", autoplay=False)

Once Loop Reflect

Colouring the same shape by one quantity at a time gives the normal force in Figure 8.14.12, the change in length in Figure 8.14.13, the strain in Figure 8.14.14 and the stress in Figure 8.14.15. Three of the four carry the same colours, because every rod shares one area and one modulus, so \(\sigma_i = N_i/A\) and \(\varepsilon_i = \sigma_i/E\) differ from the force only by a constant. Only the elongation breaks the pattern, and it breaks it at rod 2, the one rod whose length is not \(L\).

Code

result_figure(nodes1, elements1, presc1, U1, 0.25, numeric(N_vec),
              r"Normal force $[P]$", r"$N={:.2f}P$", support_angles=walls)

Code

result_figure(nodes1, elements1, presc1, U1, 0.25, numeric(d_vec),
              r"Elongation $[PL/EA]$", r"$\delta={:.2f}$", support_angles=walls)

Code

result_figure(nodes1, elements1, presc1, U1, 0.25, numeric(eps_vec),
              r"Strain $[P/EA]$", r"$\varepsilon={:.2f}$", support_angles=walls)

Code

result_figure(nodes1, elements1, presc1, U1, 0.25, numeric(sigma_vec),
              r"Stress $[P/A]$", r"$\sigma={:.2f}$", support_angles=walls)

Equilibrium of the joints

\(\bm A^\mathsf{T}\) has one row for each entry of \(\bm f\) and one column for each rod, so here it is \(6 \times 5\). The rows come from equilibrium of the nodes. We cut each node free as in Figure 8.14.17 to Figure 8.14.19, draw every rod force positive in tension, and balance the forces in \(x\) and in \(y\). Each balance is one row.

A rod in tension pulls a node towards the rod’s far end, and the nodal force \(f_j\) must balance that pull. The coefficient of \(N_i\) in the equation for \(f_j^x\) is therefore the \(x\) component of the unit vector that points along rod \(i\) from its far end towards node \(j\), and likewise for \(y\). A rod that does not touch node \(j\) does not pull on it, and its coefficient is zero.

At node 2, for example, rod 1 comes from node 1 on the left, so its unit vector towards node 2 is \((1, 0)\). Rod 2 comes from node 3 above, giving \((0, -1)\). The diagonal rod 5 comes from node 4 at the top left, giving \((1, -1)/\sqrt2\). Rods 3 and 4 do not reach node 2. Doing the same at nodes 3 and 4, and writing every rod in every equation, including those with coefficient zero, gives

\[ \begin{array}{rcrcrcrcrcr} & & \scriptstyle\text{rod 1} & & \scriptstyle\text{rod 2} & & \scriptstyle\text{rod 3} & & \scriptstyle\text{rod 4} & & \scriptstyle\text{rod 5}\\[2pt] f_2^x &=& 1\,N_1 &\quad+\quad& 0\,N_2 &\quad+\quad& 0\,N_3 &\quad+\quad& 0\,N_4 &\quad+\quad& \tfrac{1}{\sqrt2}\,N_5\\[4pt] f_2^y &=& 0\,N_1 &\quad-\quad& 1\,N_2 &\quad+\quad& 0\,N_3 &\quad+\quad& 0\,N_4 &\quad-\quad& \tfrac{1}{\sqrt2}\,N_5\\[4pt] f_3^x &=& 0\,N_1 &\quad+\quad& 0\,N_2 &\quad+\quad& 1\,N_3 &\quad+\quad& 0\,N_4 &\quad+\quad& 0\,N_5\\[4pt] f_3^y &=& 0\,N_1 &\quad+\quad& 1\,N_2 &\quad+\quad& 0\,N_3 &\quad+\quad& 0\,N_4 &\quad+\quad& 0\,N_5\\[4pt] f_4^x &=& 0\,N_1 &\quad+\quad& 0\,N_2 &\quad-\quad& 1\,N_3 &\quad+\quad& 0\,N_4 &\quad-\quad& \tfrac{1}{\sqrt2}\,N_5\\[4pt] f_4^y &=& 0\,N_1 &\quad+\quad& 0\,N_2 &\quad+\quad& 0\,N_3 &\quad+\quad& 1\,N_4 &\quad+\quad& \tfrac{1}{\sqrt2}\,N_5 \end{array} \]

The rows are in the order of \(\bm u\) and \(\bm f\), and within every row the rod forces stand in the same order, \(N_1\) to \(N_5\), each in its own column. The system is already a matrix product. Collecting the coefficients, with their signs, row by row gives \(\bm A^\mathsf{T}\):

\[ \begin{bmatrix} f_2^x \\ f_2^y \\ f_3^x \\ f_3^y \\ f_4^x \\ f_4^y \end{bmatrix} = \underbrace{\begin{bmatrix} 1 & 0 & 0 & 0 & \tfrac{1}{\sqrt2}\\[2pt] 0 & -1 & 0 & 0 & -\tfrac{1}{\sqrt2}\\[2pt] 0 & 0 & 1 & 0 & 0\\[2pt] 0 & 1 & 0 & 0 & 0\\[2pt] 0 & 0 & -1 & 0 & -\tfrac{1}{\sqrt2}\\[2pt] 0 & 0 & 0 & 1 & \tfrac{1}{\sqrt2} \end{bmatrix}}_{\bm A^\mathsf{T}} \begin{bmatrix} N_1 \\ N_2 \\ N_3 \\ N_4 \\ N_5 \end{bmatrix} \]

Columns 1 and 4 have entries in the rows of one node only, because rods 1 and 4 each have their other end at the fixed node 1, which has no rows. Columns 2, 3 and 5 have entries at both ends of their rod, equal and of opposite sign, since a rod pulls its two nodes towards each other.

Assembling

The material matrix is

\[ \bm K^e = \frac{EA}{L}\operatorname{diag}\left(1,\ 1,\ 1,\ 1,\ \tfrac{1}{\sqrt2}\right) \]

and the assembly is the product of 8.14.6, and at six by six it is work for the computer.

s = 1/r2
A_T = sp.Matrix([[1,  0,  0, 0,  s],
                 [0, -1,  0, 0, -s],
                 [0,  0,  1, 0,  0],
                 [0,  1,  0, 0,  0],
                 [0,  0, -1, 0, -s],
                 [0,  0,  0, 1,  s]])

K_e = (E*A/L) * sp.diag(1, 1, 1, 1, 1/r2)

K = sp.simplify(A_T * K_e * A_T.T)
ltx(r"\bm K = \frac{EA}{L}", sp.simplify(K/(E*A/L)))

The matrix is symmetric, as before, and it is singular: \(\det\bm K = 0\). Without the roller the truss could turn about the pin at node 1 without deforming a single rod, and a structure that can move without deforming has no unique displacement for a given load. The roller is what makes the problem solvable.

Removing the supported degree of freedom

Written out, \(\bm K\bm u = \bm f\) contains the known displacement \(u_2^y = 0\) and, in the same position of the load vector, the unknown reaction \(f_2^y\),

\[ \begin{bmatrix} K_{11} & \color{red}{K_{12}} & K_{13} & \cdots & K_{16}\\ \color{red}{K_{21}} & \color{red}{K_{22}} & \color{red}{K_{23}} & \color{red}{\cdots} & \color{red}{K_{26}}\\ K_{31} & \color{red}{K_{32}} & K_{33} & \cdots & K_{36}\\ \vdots & \color{red}{\vdots} & \vdots & \ddots & \vdots\\ K_{61} & \color{red}{K_{62}} & K_{63} & \cdots & K_{66} \end{bmatrix} \begin{bmatrix} u_2^x \\ \color{red}{u_2^y = 0} \\ u_3^x \\ \vdots \\ u_4^y \end{bmatrix} = \begin{bmatrix} 0 \\ \color{red}{f_2^y} \\ 0.7P \\ \vdots \\ \tfrac45 P \end{bmatrix} \]

Column 2 multiplies \(u_2^y = 0\) and contributes nothing, and row 2 is the only equation that contains the unknown \(f_2^y\). Deleting both leaves five equations for the five unknown displacements, those of the free degrees of freedom 1, 3, 4, 5 and 6. We number them from one, as in the equations, and let OneArray pick out the rows and columns.

from mechanicskit import OneArray

ff = P*sp.Matrix([0, 0, sp.Rational(7, 10), -sp.Rational(3, 10),
                  sp.Rational(3, 5), sp.Rational(4, 5)])     # f_2^y = 0 is a placeholder

free = [1, 3, 4, 5, 6]                                        # degree-of-freedom numbers
K_ff = sp.Matrix(OneArray(K)[free, free])
f_f = sp.Matrix(OneArray(ff)[free])

uu = OneArray(sp.zeros(6, 1))
uu[free] = K_ff.LUsolve(f_f)
uu = sp.simplify(sp.Matrix(uu))

ltx(r"\bm u = \frac{PL}{EA}", sp.simplify(uu/(P*L/(E*A))), r"\approx \frac{PL}{EA}",
    (uu/(P*L/(E*A))).evalf(4))

With the displacements known, the rod forces follow from \(\bm N = \bm K^e\bm A\bm u\) as in Example 1, and the full product \(\bm K\bm u\) returns every nodal force, including the reaction \(f_2^y\) that was set aside.

NN = sp.simplify(K_e * A_T.T * uu)
f_all = sp.simplify(K * uu)

ltx(r"\bm N &=", sp.simplify(NN/P), r"P \approx", (NN/P).evalf(4), r"P",
    r"\\ f_2^y &=", f_all[1], aligned=True)

The diagonal rod 5 carries the largest force, \(1.84P\) in compression, and rod 4 the largest tension, \(2.1P\). The roller reaction checks against a moment balance about node 1: the loads at nodes 3 and 4 turn the truss clockwise with \(0.3PL + 0.7PL + 0.6PL = 1.6PL\), and the roller, a distance \(L\) from the pin, answers with \(1.6P\).

Removing the supported degree of freedom also left \(\bm A^\mathsf{T}\) with five rows and five columns. It is square, so by the note in Example 1 this truss is statically determinate, and the rod forces follow from the loads alone, without \(E\), \(A\) or \(L\):

A_T_f = sp.Matrix(OneArray(A_T)[free, :])
ltx(r"(\bm A^\mathsf{T}_f)^{-1}\bm f_f = ", sp.simplify(A_T_f.inv()*f_f/P), r"P")

The result is \(\bm N\) again. Setting \(E = A = L = P = 1\) turns this example into numbers too, and Figure 8.14.20 draws the truss where the loads take it. A joint here travels close to eight rod lengths, so the picture is drawn at a twentieth of that, growing from nothing so that the path of each joint can be seen.

Code

nodes2 = np.array([[0, 0], [1, 0], [1, 1], [0, 1]], dtype=float)  # row i is node i
elements2 = np.array([[1, 2], [2, 3], [3, 4], [1, 4], [2, 4]])    # rod k joins these two
presc2 = [1, 2, 4]              # the pin holds dofs 1 and 2, the roller holds dof 4
U2 = np.vstack([[0, 0], numeric(uu).reshape(3, 2)])

fig2 = plt.figure(figsize=(4.6, 4.6))
ax2 = fig2.add_axes([0, 0, 1, 0.94])

anim2 = animate_truss(nodes2, elements2, U2, presc=presc2,
                      loads=[[3, 0.7, -0.3], [4, 0.6, 0.8]],
                      scale_max=0.05, frames=20, ax=ax2,
                      title="deformation scale {scale:.3f}")
to_responsive_html(anim2, container_id="truss-ex2-deformation", autoplay=False)

Once Loop Reflect

Both top nodes move close to \(8\,PL/EA\) to the right, although no rod changes length by more than \(2.6\,PL/EA\). The square racks: the loads push its top to the right, and only the diagonal rod 5 resists that, by shortening.

The rods in colour

One shape serves four figures: the normal force in Figure 8.14.21, the change in length in Figure 8.14.22, the strain in Figure 8.14.23 and the stress in Figure 8.14.24. The elongations follow from \(\bm\delta = \bm A\bm u\), the strains from \(\varepsilon_i = \delta_i/L_i\) and the stresses from \(\sigma_i = N_i/A\). Force, stress and strain again differ only by a constant, so only the elongation departs from their pattern, and it departs at the diagonal rod 5.

dd = sp.simplify(A_T.T * uu)
L_vec2 = sp.Matrix([L, L, L, L, r2*L])
sigma_vec2 = sp.simplify(NN/A)
eps_vec2 = sp.simplify(sp.Matrix([dd[i]/L_vec2[i] for i in range(5)]))

ltx(r"\bm\delta &=", sp.nsimplify(dd/(P*L/(E*A))).evalf(4), r"\,\frac{PL}{EA}",
    r"\\ \bm\sigma &=", sp.nsimplify(sigma_vec2/(P/A)).evalf(4), r"\,\frac{P}{A}",
    r"\\ \bm\varepsilon &=", sp.nsimplify(eps_vec2/(P/(E*A))).evalf(4), r"\,\frac{P}{EA}",
    aligned=True)

Code

result_figure(nodes2, elements2, presc2, U2, 0.05, numeric(NN),
              r"Normal force $[P]$", r"$N={:.2f}P$")

Code

result_figure(nodes2, elements2, presc2, U2, 0.05, numeric(dd),
              r"Elongation $[PL/EA]$", r"$\delta={:.2f}$")

Code

result_figure(nodes2, elements2, presc2, U2, 0.05, numeric(eps_vec2),
              r"Strain $[P/EA]$", r"$\varepsilon={:.2f}$")

Code

result_figure(nodes2, elements2, presc2, U2, 0.05, numeric(sigma_vec2),
              r"Stress $[P/A]$", r"$\sigma={:.2f}$")

A settling support

Suppose instead that the roller sinks by \(u_2^y = -\tfrac15\,PL/EA\). Column 2 of \(\bm K\) now multiplies a value that is not zero, so it cannot be deleted. Its contribution is known, however, and moves to the right-hand side,

\[ \bm K_{ff}\,\bm u_f = \bm f_f - \bm K_{fp}\,u_2^y \]

where \(\bm K_{fp}\) is column 2 without its second entry. Figure 8.14.25 shows the two steps: the column is multiplied by the known \(u_2^y\) and carried across to the right-hand side, and only then are row 2 and column 2 struck out. Section 8.15.8 treats the general case.

presc = [2]
u_p = sp.Matrix([-P*L/(5*E*A)])
K_fp = sp.Matrix(OneArray(K)[free, presc])

uu_s = OneArray(sp.zeros(6, 1))
uu_s[presc] = u_p
uu_s[free] = K_ff.LUsolve(f_f - K_fp*u_p)
uu_s = sp.simplify(sp.Matrix(uu_s))
NN_s = sp.simplify(K_e * A_T.T * uu_s)

ltx(r"\bm u_{\text{settled}} - \bm u &=", sp.simplify((uu_s - uu)/(P*L/(E*A))), r"\frac{PL}{EA}",
    r"\\ \bm N_{\text{settled}} - \bm N &=", sp.simplify(NN_s - NN), aligned=True)

Not one rod force changes. The extra displacements, \(0.2\,PL/EA\) down at node 2, right and down at node 3 and right at node 4, are those of a rigid rotation about the pin at node 1 by the angle \(P/(5EA)\). A statically determinate truss follows a settling support without resistance, because the loads already fix every rod force through equilibrium. In the statically indeterminate truss of Example 1, moving a support would stretch or compress the rods and load them.