# The Method of Joints: Part 2

See Part 1.

With the theory established, the python script was simple enough to write. Prior to this project I hadn’t used numpy before, but after seeing some examples online involving matrix operations, I figured numpy was the perfect tool.

The script is split into 9 major steps:

- Read data from the input files
- Construct the members table, filled with the coefficients and
- Construct the coefficient matrix and the vector of applied forces
- Solve the matrix equation!
- Find the maximum safe load for the truss
- Present the results

All the relevant data are kept in a few separate files, which are imported into some `ndarray`

s:

`joints.in`

: containing the (x,y) coordinates of each numbered joint, in mm`members.in`

: a list of members with their two associated joints`supports.in`

: the two supported joints and whether it is a pin or roller support`applied.in`

: the forces applied to the truss, and their locations`material.in`

: the physical properties of the material we’re using

The first four use `numpy.genfromtxt()`

to form their arrays, but `material.in`

is imported into a dictionary:

material = {} with open(inpath+'material.in', 'r') as fin: for line in fin: if (line[0] != '#'): spl = line.split() if len(spl)==2: (key, value) = spl material[key] = float(value)

This way the material properties can be accessed easily, for example the Young’s modulus is `material['E']`

The members table initially has three columns: the member number, the number of joint , and the number of joint . The table is extended with a few empty columns, which are filled in with the relevant geometric properties of the member (taken from the (x,y) coordinates of it’s two joints): , , , , .

Constructing is pretty much as described in Part 1: the and values for each member are inserted in the appropriate place, and then the coefficients for the reaction forces are added in to the final three columns. These coefficients are 1 as they’re aligned with the axes. The applied forces are inserted into a vector “”

Solving the matrix equation is the easy part and it’s why I chose numpy in the first place:

Q = numpy.linalg.solve(C,P)

I’ve been setting up the applied forces to sum to 1, so now contains the portion of the load which is carried by each member. For example if Q[3] = -0.707, this means member #3 is carrying a compressive force of 0.707*(Load).

The maximum load for the truss as a whole is found by iterating through the members and finding the maximum load for the bridge before that member fails, then taking the lowest of these failure limits. This isn’t a rigorous analysis and only yielding and Euler buckling are accounted for, but that’s good enough for a bridge made of plastic straws:

maxL_t = np.zeros([members.shape[0],3]) maxL = 1e6 for k in range(members.shape[0]): if Q[k] != 0: # yield: F/A <= (safety factor) * s_y maxL_t[k,0] = material['sf'] * material['s_y'] * material['A'] / abs(Q[k]) # buckling: F <= (safety factor) * pi^2 * E * I / l^2 if Q[k] < 0: maxL_t[k,1] = material['sf'] * numpy.pi**2 * material['E'] * material['I'] \ / (abs(Q[k]) * members[k,5]**2) # which is the smaller limit? maxL_t[k,2] = min(maxL_t[k,0], maxL_t[k,1]) else: maxL_t[k,2] = maxL_t[k,0] if maxL_t[k,2] < maxL: maxL = maxL_t[k,2]

And with that the analysis is complete. I’ve set up two modes of output: a plaintext mode, where the results are sent straight to a text file; and a presentation mode, where matplotlib is used to draw the bridge and the results are written to an .html page like this one!

# The Method of Joints: Part 1

In one of my courses we’ve been tasked with building a truss bridge out of plastic tubes, slightly thicker than drinking straws, which must span 1 metre and hold 5kg of load. My team had a few basic designs that we wanted to start off with, which meant a whole bunch of calculation to see which one was best. Of course I’m not one to pass up an opportunity like that, and solving systems of linear equations is something that computers are kind-of alright at, so I wrote a python script that solves a given truss and returns the internal forces in each member. With the script complete, a new bridge design takes only about 2 minutes from data input to final results! The slowest step is sketching the bridge design…

The method of joints involves stepping through each joint in a truss and solving the equations of static equilibrium, i.e.

These two equations must be solved for each joint, giving equations, where is the number of joints present. The procedure is quite straightforward but having more than a few joints makes it get tedious very quickly. So, let’s make it faster.

Consider the frame above (with members 1 & 2 the same length). We have six unknowns to solve for: three reaction forces from the supports, and the three internal forces. We also have six equations describing the system, how convenient. These are:

Now this system is simple enough to solve by inspection. Ignoring this though, we can represent this system as a matrix equation , where is a vector of the applied (or known) forces, is a vector of our unknowns, and is the coefficient matrix. Thus:

As long as the matrix is non-singular, we can find it’s inverse and recover the solution . In this case:

That was easy! Now comes the question of somehow constructing the matrix for an arbitrary truss, without actually writing the equations by hand.

First, note that for a simple truss (constructed only of triangles) with joints, there are members connecting them. If the truss is supported by three support forces, for example above, then the system is statically determinate: there are equations describing the system and unknowns to solve for.

Now consider an arbitrary member in a truss, connected between two joints and . The equations

are the only equations with any contribution from member (as a member can only connect to two joints), and we can number these equations as , , , and respectively. The member will appear in exactly these four equations, although the coefficient may be zero as with in the example above.

Looking at the x-component of forces at joint , (equation number ):

We can simplify this a little by using ratios of the member’s dimensions rather than it’s angle. By defining

and by moving the known/applied force to the right hand side of the equation, we get the following:

In the matrix , the entire column will be zero except for the rows corresponding to these equations. So the contributions to from member are:

With complete, we just construct the vector as above, with in order, and the three support reaction forces at the end. The vector of applied forces is simple enough: for a load applied at node we just set

And now we just find , solve , and we’re done!

## Recent Comments