The Cantilevered Beam Problem:
Linearly Distributed Load Case

Van Warren
Warren Design Vision
Little Rock, Arkansas
July 5, 1994

Problem

A cantilevered beam is subjected to a truncated distributed load that varies linearly along its span:

Determine the reaction and moment at the supports, the deflection along the span, the slope at the endpoints, the shear and the bending moment.

Variables

L  = beam length
	a  = x coordinate of load start
	b  = x coordinate of load end (0 ≤ a < b ≤ L)
	Ra = the reaction at support A
	Ma = the moment at support A
	wm = slope of spanwise load function
	wb = intercept of spanwise load function
	y(x)  = deflection as a function of x
	V(x)  = shear as a function of x
	M(x)  = bending moment as a function of x

	A subscript of '1', refers to interval 0 ≤ x ≤ a
	A subscript of '2', refers to interval a ≤ x ≤ b
	A subscript of '3', refers to interval b ≤ x ≤ L

Note that the point x = a is shared by intervals 1 & 2.  Similarly the point x = b is shared by intervals 2 & 3.

Initializations

x =.
Ra =.
Ma =.

strip2[u_] := First[First[u]] ;
ruleToEquality[u_] :=  u /. Rule -> Equal ;
equalityToRule[u_] :=  u /. Equal -> Rule ;
ruleToSet[u_] :=  u /. Rule -> Set ;
ruleToFunction[u_] :=  u /. Rule -> SetDelayed ;
rePresent[u_] := strip2[u] ;
enSconce[u_] := ruleToEquality[u] ;

srf[s_, l_]:=StringReplace[s,Join[{"["->"(", "]"->")"},l]];

numFix[s_]:=
StringReplace[s,
{
	"EI"->"(E*I)",
	"1.*"->"",
	"0.3333333333333333333"->"(1/3)",
	"(-x^2"->"(-(x^2)",
	"(-a^2"->"(-(a^2)",
	"(-b^2"->"(-(b^2)",
	"(-x^4"->"(-(x^4)",
	"(-a^4"->"(-(a^4)",
	"(-b^4"->"(-(b^4)"
}
];

tsf[s_] := ToString[s, FormatType->InputForm];

fix[e_, l_] := srf[tsf[e], l];

outPut[e_] := Print[numFix[numFix[ToString[InputForm[e]]]]];

Sum Forces & Moments

First we sum forces and moments to deduce the values of the reactions at supports A and B.  Then we will produce expressions to describe the deflection, shear and bending moments.

The expression for the distributed load is:

where the coefficients are constants.

Summing forces and moments we produce the following in Mathematica™ notation:

forcesEqn = Ra - Integrate[wm x   + wb  , {x, a, b}] == 0;
momentEqn = Ma - Integrate[wm x^2 + wb x, {x, a, b}] == 0;

reactions =
	First	[
	Simplify	[
				Solve[{forcesEqn, momentEqn}, {Ra, Ma}]
				]
			];
reactions =
{
Ra -> Collect[Last[First[reactions]], {wb, wm, L}],
Ma -> Collect[Last[Last [reactions]], {wm, wb, L}]
};

The following expressions can be output to a spreadsheet or program for repetitive evaluation under varying conditions:

outPut[First[reactions]]
outPut[Last [reactions]]

Shear and Bending

For a detailed discussion of the behavior of the shear as we cross the boundaries see the Simple LF* proof.  We will begin with shear:

Which gives us a complete result for shear.  Now we proceed with bending moment in each of the three intervals:

Which gives us a complete result for bending.

Solve For Shear and Bending 0 <= x <= a

shear1 = V1[x] -> Ra;

bending1 = {M1'[x] == V1[x] /. shear1};
bending1 = rePresent[DSolve[bending1, M1[x], x]];
Reverse[bending1 /. x -> 0 /. M1[0] -> -Ma]; (*watch sign*)
bending1 = bending1 /. %;

outPut[shear1]
outPut[bending1]

Solve For Shear and Bending a < x <= b

V2'[x] == -(wm x + wb);
shear2 = enSconce[strip2[DSolve[%, V2[x], x]]];
shear2	/. x -> a /. V2[a] -> V1[a] /. V1[a] -> Ra;
Solve[%, C[1]];
shear2 = First[shear2 /. %];
shear2 = V2[x] -> Collect[Last[shear2],{wb, wm, L}];

M2'[x] == V2[x]  /. shear2;
bending2 = rePresent[DSolve[%, M2[x], x]]
First[
	Solve[
		enSconce[
			bending2 /. x -> a /. M2[a] -> (Ra a - Ma) (*sign*)
				],
			C[1]
		 ]
	 ]

bending2 = bending2 /. %;
bending2 = M2[x] ->
Simplify[Collect[Last[bending2],{wb, wm, x, L}]];

outPut[shear2]
outPut[bending2]

Solve For Shear and Bending b < x <= L

shear3   = V3[x] -> 0;

M3'[x] == V3[x] /. shear3;
bending3 = First[enSconce[DSolve[%, M3[x], x]]];
Solve[Reverse[bending3 /. x -> L /. M3[L] -> 0], C[1]];
bending3 = strip2[equalityToRule[Simplify[bending3 /. %]]];

outPut[shear3]
outPut[bending3]

Slope and Displacement

To compute spanwise deflection and slope we must refer to linear bending theory which (under the assumption of constant stiffness) yields:

Solve For Slope and Displacement 0 <= x <= a

dy1dx'[x] == M1[x]/(EI) /. bending1;
slope1 = rePresent[DSolve[%, dy1dx[x], x]] /. C[1] -> C1;

y1'[x] == Last[slope1];
displacement1 = rePresent[DSolve[%, y1[x], x]] /. C[1] -> C2;

outPut[slope1]
outPut[displacement1]

Solve For Slope and Displacement a < x <= b

dy2dx'[x] == M2[x]/(EI) /. bending2;
slope2 = rePresent[DSolve[%, dy2dx[x], x]] /. C[1] -> C1p;
slope2 = dy2dx[x] ->
	Collect[Collect[Last[slope2], {wb, wm, EI}], EI];
	
y2'[x] == Last[slope2];
displacement2 = rePresent[DSolve[%, y2[x], x]] /. C[1] -> C2p;
displacement2 = y2[x] ->
Collect[Collect[Last[displacement2], {wb, wm, EI}], EI];

outPut[slope2]
outPut[displacement2]

Solve For Slope and Displacement b < x <= L

dy3dx'[x] == M3[x]/(EI) /. bending3;
slope3 = rePresent[DSolve[%, dy3dx[x], x]] /. C[1] -> C1pp;
slope3 = dy3dx[x] ->
	Collect[Collect[Last[slope3], {Rb, EI}], EI];


y3'[x] == Last[slope3];
displacement3 =
	rePresent[DSolve[%, y3[x], x]] /. C[1] -> C2pp;
displacement3 = y3[x] ->
	Collect[Collect[Last[displacement3], {Rb, EI}], EI];


outPut[slope3]
outPut[displacement3]

Boundary Condition Simultaneous Equations

Having completed our slope and displacement integration we now evaluate the constants.  This proves to be the following set of simultaneous equations:

bc1 = enSconce	[
				Reverse	[
						displacement1 /. x->0 /. y1[0]->0
						]
				];
bc2 = enSconce	[
				Reverse	[
						slope1 /. x->0 /. dy1dx[0]->0
						]
				];
bc3 =
(
	(
		(Last[displacement1] /. x-> a) -
		(Last[displacement2] /. x-> a)
	) == 0
);
bc4 =
(
	(
		(Last[slope1] /. x -> a) -
		(Last[slope2] /. x -> a)
	) == 0
);
bc5 =
(
	(
		(Last[displacement2] /. x-> b) -
		(Last[displacement3] /. x-> b)
	) == 0
);
bc6 =
(
	(
		(Last[slope2] /. x -> b) -
		(Last[slope3] /. x -> b)
	) == 0
);
constants = First	[
			Simplify[
			Solve	[
						{bc1, bc2, bc3, bc4, bc5, bc6},
						{C1, C2, C1p, C2p, C1pp, C2pp}
					]
					]
					];

collector[u_] :=
	First[u] ->
	Simplify[
		Collect[
			Collect[Last[u],
			{wm, wb, EI, Ra, Rb}], EI
			   ]
			];
			
outPut[foo1 = collector[constants[[1]]]]
outPut[foo2 = collector[constants[[2]]]]
outPut[foo3 = collector[constants[[3]]]]
outPut[foo4 = collector[constants[[4]]]]
outPut[foo5 = collector[constants[[5]]]]
outPut[foo6 = collector[constants[[6]]]]

End Slopes

Our only remaining errand is to evaluate the slope expression at the endpoints and to remember that end slopes come out in radians:

leftEndSlope = Simplify[slope1 /. x->0];
riteEndSlope = Simplify[slope3 /. x->L];

outPut[leftEndSlope]
outPut[riteEndSlope]

Output

Output useable deflection expressions.

deflExpr =
	IF[AND[0<=x,x<=a],A1,IF[AND[a<x,x<=b],A2, A3]] /.
	A1 -> Last[displacement1] /.
	A2 -> Last[displacement2] /.
	A3 -> Last[displacement3];

outPut[fix[deflExpr,{"C" -> "a_C","EI" -> "(E*I_a)"}]]
outPut[fix[deflExpr,{"C" -> "b_C","EI" -> "(E*I_b)"}]]
outPut[fix[deflExpr,{"C" -> "c_C","EI" -> "(E*I_c)"}]]

Output useable constant expressions.

outPut[fix[foo1,{"C" -> "a_C","EI" -> "(E*I_a)"}]]
outPut[fix[foo2,{"C" -> "a_C","EI" -> "(E*I_a)"}]]
outPut[fix[foo3,{"C" -> "a_C","EI" -> "(E*I_a)"}]]
outPut[fix[foo4,{"C" -> "a_C","EI" -> "(E*I_a)"}]]
outPut[fix[foo5,{"C" -> "a_C","EI" -> "(E*I_a)"}]]
outPut[fix[foo6,{"C" -> "a_C","EI" -> "(E*I_a)"}]]

Testing

Convert displacement functions.

ruleToFunction[displacement1]
ruleToFunction[displacement2]
ruleToFunction[displacement3]

?y1

?y2

?y3

Input parameters for a realistic example.

inputs =
{
	L->36, a->12, b->24,
	wm->(-720/(36^2)), wb->20, EI->(402311.4063)
};

nconstants = constants /. reactions /. inputs

tmp1 = y1[x] /. nconstants /. reactions /. inputs;
tmp2 = y2[x] /. nconstants /. reactions /. inputs;
tmp3 = y3[x] /. nconstants /. reactions /. inputs;

yA[x_] := tmp1;
yB[x_] := tmp2;
yC[x_] := tmp3;

y[x_] := Which[And[ 0<=x, x<  12], yA[x],
               And[12<=x, x<  24], yB[x],
               And[24<=x, x<= 36], yC[x]]

reactions /. inputs

Plot displacement functions.

Plot[Evaluate[y[x]], {x, 0, 36}]

Cross verification example problems.

Example Problem 1:

We first run a BeamCALCulator™ that only handles a uniform load:

Load Parameters

Load wm:  0;	Slope of spanwise load function
Load wb: 10 lbs/in;	Uniform Load
Length:  36 in;

Material Parameters

Material:     Aluminum 6061 T-6
Elastic Modulus: 10,100,000 psi
Yield Strength:      35,000 psi (Tensile)
Density:              0.098 pci

Cross Sectional Parameters

Outer Width  W: 1.00 inches
Inner Width  w: 0.85 inches
Outer Height H: 1.00 inches
Inner Height h: 0.85 inches

Example Problem 2:

We then run a BeamCALCulator™ that handles a linearly varying load with the uniform load case and compare the results:

Load Parameters

Load wm:  -720/L^2=.56 lbs/in2	Spanwise load slope
Load wb: 20 lbs/in;	Uniform Load
Length:  36 in;

Material Parameters

Same as Problem 1.

Example Problem 3:

We then run a BeamCALCulator™ that handles a linearly varying load with a tapered load case whose end support reactions are the same and compare the results:

Load Parameters
Load Start a: 12 inches
Load End   b: 24 inches
Load wm:  -720/L^2=.56 lbs/in2	Spanwise load slope
Load wb: 20 lbs/in;			Uniform Load
Length:  36 in;

Material Parameters

Same as Problem 1.