Macaulay’s Method is a convenient method of applying beam slope-deflection equations to find the shear forces, bending moments, slopes and deflections of a structural beam subject to complex load conditions, including partial varying distributed loads and point loads and moments.  It is described in Wikipedia, and in more detail, with numerous examples by Colin Caprani.  I have developed a spreadsheet using this method to analyse simply supported beams, continuous beams, and to find fixed end moments.  The spreadsheet, including full open source code, may be downloaded from Macaulay.zip.

This post describes the background, and the User Defined Functions (UDFs) for analysis of simply supported beams.  Later posts will look at the extension of the method to fixed end actions, continuous beams, spring supports, shear deflections etc.

The essence of the method is to use “Macualay bracket” notation to integrate applied loads from the point at which they first become active up to the end of the beam.  If a load is terminated before the end of the beam then an equal and opposite load must be applied from that point to correctly model the applied loading.  Quoting Wikipedia:

This procedure is carried out by the UDF SSSpan():

• Transfer beam and load data from the spreadsheet
• Take moments about the left hand support to find the end support reactions
• Set up an array of integration limits
• Solve for shear forces, bending moments, curvatures, slopes and deflections, assuming zero rotation at the left hand end; adjusting for variations in the section stiffness if required.
• Rotate for zero deflection at the right hand end..
• Output results.

Function input and output are shown in the screenshots below:

SSSPan Input

SSSPan Output

Example Input

Load Distribution

Output compared with Strand7 analysis of the same data (click for full size view)

Output Shear Forces

Output Bending Moments and Deflections

Full open source code is included in the download spreadsheet. The extracts below show how Macaulay’s Method is performed in the VBA code. The output results are generated in a 5 column array called SSRes, the columns being:

1. X: distance of the section from the left hand end
2. Shear force = integral of distributed applied loads + point loads + reaction at the left hand support
3. Moment = integral of the shear force + applied moments
4. Slope = integral of curvature = integral of Moment/EI (EI = section flexural stiffness)
5. Deflection = integral of slope

Note that columns 4 and 5 are initially determined with a unit EI value, then corrected for the specified EI.  This procedure is required to handle beams with varying flexural stiffness along their length.

Evaluate for distributed loads

    For i = 1 To NumSegments
        If i > 1 Then X0 = Segments(i - 1, 1) Else X0 = 0
        X = Segments(i, 1)
        DX = X - X0

    ' Distributed loads
        For j = 1 To NumDloads

            X1 = DLoads(j, 1)
            X2 = DLoads(j, 2)
            Q = DLoads(j, 3)
            QNeg = -DLoads(j, 4)
            If X2 <> X1 Then Qdash = (DLoads(j, 4) - DLoads(j, 3)) / (X2 - X1) Else Qdash = 0
            DX1 = X - X1
            If DX1 < 0 Then DX1 = 0
            DX2 = X - X2
            If DX2 < 0 Then DX2 = 0

            SSRes(i + 1, 2) = SSRes(i + 1, 2) + Q * DX1 + Qdash * DX1 ^ 2 / 2 + QNeg * DX2 - Qdash * DX2 ^ 2 / 2
            SSRes(i + 1, 3) = SSRes(i + 1, 3) + Q * DX1 ^ 2 / 2 + Qdash * DX1 ^ 3 / 6 + QNeg * DX2 ^ 2 / 2 - Qdash * DX2 ^ 3 / 6
            SSRes(i + 1, 4) = SSRes(i + 1, 4) + (Q * DX1 ^ 3 / 6 + Qdash * DX1 ^ 4 / 24 + QNeg * DX2 ^ 3 / 6 - Qdash * DX2 ^ 4 / 24)
            SSRes(i + 1, 5) = SSRes(i + 1, 5) + (Q * DX1 ^ 4 / 24 + Qdash * DX1 ^ 5 / 120 + QNeg * DX2 ^ 4 / 24 - Qdash * DX2 ^ 5 / 120)

        Next j

Then point loads and moments

        ' Point loads
        For j = 1 To NumPloads
            X1 = PLoads(j, 1)
            DX1 = X - X1
            W = PLoads(j, 2)
            If DX1 < 0 Then DX1 = 0
            If DX1 > 0 Then
                SSRes(i + 1, 2) = SSRes(i + 1, 2) + W
                SSRes(i + 1, 3) = SSRes(i + 1, 3) + W * DX1
                SSRes(i + 1, 4) = SSRes(i + 1, 4) + (W * DX1 ^ 2 / 2)
                SSRes(i + 1, 5) = SSRes(i + 1, 5) + (W * DX1 ^ 3 / 6)
            End If
        Next j

        ' Moments
        If PloadCols > 2 Then
            For j = 1 To NumPloads
                X1 = PLoads(j, 1)
                DX1 = X - X1
                W = -PLoads(j, 3)
                If DX1 < 0 Then DX1 = 0
                If DX1 > 0 Then
                    SSRes(i + 1, 3) = SSRes(i + 1, 3) + W
                    SSRes(i + 1, 4) = SSRes(i + 1, 4) + W * DX1
                    SSRes(i + 1, 5) = SSRes(i + 1, 5) + (W * DX1 ^ 2 / 2)
                End If
            Next j

        End If
    Next i

Add end actions

   For i = 1 To NumSegments
        X = Segments(i, 1)
        If i = 1 Then DX = X Else DX = X - Segments(i - 1, 1)
        SSRes(i + 1, 1) = X
        SSRes(i + 1, 2) = SSRes(i + 1, 2) + SSRes(1, 2)
        SSRes(i + 1, 3) = SSRes(i + 1, 3) + SSRes(1, 3) + SSRes(1, 2) * X
        SSRes(i + 1, 4) = SSRes(i + 1, 4) + SSRes(1, 4) + (SSRes(1, 3) * X + SSRes(1, 2) * X ^ 2 / 2)
        SSRes(i + 1, 5) = SSRes(i + 1, 5) + SSRes(1, 4) * X + SSRes(1, 5) + (SSRes(1, 3) * X ^ 2 / 2 + SSRes(1, 2) * X ^ 3 / 6)
    Next i

Finally adjust slope and deflection for EI of each segment

    ' Adjust slope and deflection for EI
    For i = 1 To NumSegments
        EI = Segments(i, 2)
        X = Segments(i, 1)
        If i = 1 Then DX = X Else DX = X - Segments(i - 1, 1)
        If i = 1 Then StartSlope = SSRes(i, 4) Else StartSlope = EndSlope
        If i = 1 Then StartDef = SSRes(i, 5) Else StartDef = EndDef

        EndSlope = StartSlope + (SSRes(i + 1, 4) - SSRes(i, 4)) / EI
        EndDef = StartDef + StartSlope * DX + (SSRes(i + 1, 5) - SSRes(i, 5) - (SSRes(i, 4) * DX)) / EI
        SSRes(i, 4) = StartSlope
        SSRes(i, 5) = StartDef
    Next i
    SSRes(i, 4) = EndSlope
    SSRes(i, 5) = EndDef

The array SSRes at this stage has correct values for shear and bending moment, but the slopes and deflections are based on zero slope at the left hand end. This is corrected by finding the slope required to make the deflection at the right hand end equal to zero, then adding this slope and the associated deflection to the output values.