The premise is that once the shear failure has occurred then the upper and lower halves of the beam will have reduced stresses from bending due to the stress redistribution. The top will have less compression and the bottom will have less tension.
Assume uniformly distributed load. $$V(x) = \frac{w L}{2} - w x$$ $$M(x) = -\frac{w x^2}{2} + \frac{w L}{2} x$$
Moment arm in beam is $\frac{2}{3} d$
To simplify the problem assume the stress is uniform over the top and bottom. Also assume a rectangular section since we are dealing with timber.
For a shear split that extends for a distance of $L/4$ $$\Delta L = \frac{1}{E}\int^{L/4}_0 \frac{3}{2} \frac{w}{b d^2} \left(-x^2 + L x \right) dx$$
Deflection due to bending is, $$\Delta = \frac{5 w L^4}{384 E I}$$ and the ratio of $\Delta L$ to $\Delta$ is, $$\frac{\Delta L}{\Delta} = \frac{\frac{5 w L^3}{128 E b d^2}}{\frac{5 w L^4}{384 E I}}$$
Since this is a rectangular section, $$\frac{\Delta L}{\Delta} = \frac{3 \frac{1}{12} b d^3}{ L b d^2}$$
Therefore $\Delta L$ as a function of $\Delta$ is,
$$\Delta L = \Delta \times \frac{d}{4 L}$$$\Delta L$ is a first order function of all the factors in the equation, so it is reasonably safe to assume that it would just be proportional to the length of the split, $L/4$ in this case. Based on that assumption we can rewrite $\Delta L$ as a function of the length of the split.
$$\Delta L\left(L_{split}\right) = \Delta \times \frac{\frac{d}{4 L}}{L/4} \times L_{split} = \Delta \times \frac{d}{4 L}\times \frac{4}{L} \times L_{split}$$or
To determine the new origin of the beam top or bottom we must use a line intergral.
$$\oint_{x_0}^{x} f(x) dx = \Delta L$$Assuming the deflected shape can be modeled by a second order curve,
$$\oint_{x_0}^{x} \left(a x^2 +b x+c \right) dx = \Delta L$$This is not a simple solution and we are only drawing a picture not making precise calculations. To simplify the problem assume that the function $dy/dx$ is a constant over the short distance $\Delta L$.
$$\Delta L = \sqrt{\Delta_x^2 + \Delta_y^2}$$$$\Delta L = \sqrt{\Delta_x^2 + (2ax_0+b)^2 \Delta_x^2}$$$$\Delta L = \Delta_x \sqrt{1 + 4a^2 x_0^2+4 a x_0 b+b^2}$$
In [1]:
# aS = arb_spline(X=[0,50,100],Y=[0,10,0],k0=0.5,k1=0,k2=-0.1)
# aS
In [2]:
# XX = lambda : "text"
# XX()
In [3]:
# from IPython.display import SVG
# txt="""<svg viewBox = "-10 -10 120 30">
# {}
# </svg>""".format(aS.svg_path_txt)
# SVG(txt)
or since $x_0$ isn't changing,
$$ x = x_0 + \frac{ \Delta L }{\sqrt{1 + 4a^2 x_0^2+4 a x_0 b+b^2}}$$substituting for $\Delta L$,
$$ x = x_0 +\frac{ \Delta \times L_{split} \times \frac{d}{ L^2} }{\sqrt{1 + 4a^2 x_0^2+4 a x_0 b+b^2}} $$
In [71]:
from SVG_beam import beam, adjust_viewbox
from SVG_lib import point, Line
from New_Spline import Spline
from CurveManip import rotate, mirror
from numpy import sqrt
from collections import namedtuple
class shear_failure(beam):
def __init__(self):
super(shear_failure,self).__init__()
self.L_split = 0.02
def split(self):
"""Takes the beam in its current configuration and adds a shear failure
Based on the assumption that the compression and tension at the top
and bottom of the beam is uniformly distributed over the upper and
lower half of the beam, the change in length of the top and bottom due
to a shear crack extending over 1/4 the length of the beam (at each end)
is only Delta times d/4L. Where Delta is the deflection due to bending
at the center of the beam, d is the depth of the beam, and L is the beam
length. For a beam that has a length of 300, a depth of 30 and a
deflection of 30 that change is only 0.75.
"""
cL = self.centerline
L = self.L
X_s = self.L_split
# This scale was added to account for moment distribution in a beam
# with a uniform distributed load.
scale = X_s*(1-X_s)
L_split = self.L_split * L #* 2
D = self.sag
D_x0 = (D*self.thickness/(L**2)*L_split)/cL.instant_slope(cL.P0)*scale
D_x3 = (D*self.thickness/(L**2)*L_split)/cL.instant_slope(cL.P3)*scale
Top_n_Bottom = namedtuple('Top_n_Bottom','top bot')
x0 = Top_n_Bottom(cL.P0[0]-D_x0,cL.P0[0]+D_x0)
x3 = Top_n_Bottom(cL.P3[0]-D_x3,cL.P3[0]+D_x3)
y0 = Top_n_Bottom(*[cL.Y_(x) for x in x0])
y3 = Top_n_Bottom(*[cL.Y_(x) for x in x3])
# Bottom of top and top of bottom are both located at the original centerline
self.bottom_of_top = Spline([x0.top,y0.top],[x3.top,y3.top],cL.Coefficients())
self.top_of_bottom = Spline([x0.bot,y0.bot],[x3.bot,y3.bot],cL.Coefficients())
if x0.top<x0.bot: # Deflecting upward and top got longer
control = self.bottom_of_top
else: # Deflecting downward and bottom got longer
control = self.top_of_bottom
xL = min(x0) + L_split
xR = max(x3) - L_split
yL = cL.Y_(xL)
yR = cL.Y_(xR)
Left = Spline(control.P0,[xL,yL],cL.Coefficients())
Right = Spline([xR,yR],control.P3,cL.Coefficients())
Left.points = False
Right.points = False
self.splits = [Left,Right]
angles = cL.end_angles()
offset = self.thickness/2
top_P0 = rotate(point(self.bottom_of_top.P0).offset_y(-offset).List(),
self.bottom_of_top.P0, angles.θ_0)
bot_P0 = rotate(point(self.top_of_bottom.P0).offset_y(offset).List(),
self.top_of_bottom.P0, angles.θ_0)
top_P3 = rotate(point(self.bottom_of_top.P3).offset_y(-offset).List(),
self.bottom_of_top.P3, angles.θ_1)
bot_P3 = rotate(point(self.top_of_bottom.P3).offset_y(offset).List(),
self.top_of_bottom.P3, angles.θ_1)
# Ends...
top = self.top[0]
bottom = self.bottom[0]
top.P0 = [float(p) for p in top_P0]
top.P3 = [float(p) for p in top_P3]
bottom.P0 = [float(p) for p in bot_P0]
bottom.P3 = [float(p) for p in bot_P3]
Left_T = Line(top.P0,self.bottom_of_top.P0)
Left_T.width = 1
Left_M = Line(self.bottom_of_top.P0,self.top_of_bottom.P0)
Left_M.width = 1
Left_B = Line(self.top_of_bottom.P0,bottom.P0)
Left_B.width = 1
Right_T = Line(top.P3,self.bottom_of_top.P3)
Right_T.width = 1
Right_M = Line(self.bottom_of_top.P3,self.top_of_bottom.P3)
Right_M.width = 1
Right_B = Line(self.top_of_bottom.P3,bottom.P3)
Right_B.width = 1
self.L_end = [Left_T, Left_M, Left_B]
self.R_end = [Right_T, Right_M, Right_B]
self.manual_ends = True
@property
def L(self):
x2,y2 = self.R_CL.List()
x0,y0 = self.L_CL.List()
L = sqrt((x2-x0)**2+(y2-y0)**2)
return L
@property
def L_split(self):
return self._L_split
@L_split.setter
def L_split(self, val):
if val > 0.5 or val <0:
er = ("L_split is a fractional amount of the beam length up to 0.5 "
"and it should be limited to 0.167 for realistic shear failure.")
raise(ValueError(er))
self._L_split = val
In [80]:
tt = shear_failure()
In [81]:
tt.sag=30
tt
Out[81]:
In [82]:
tt.show_center_line = False
tt.display_points = False
In [83]:
tt.sag = 30
corners = tt.get_corners()
S = tt.support_points()
tt
Out[83]:
In [79]:
# tt.L_split = 0.25
# tt.split()
# tt
Out[79]:
In [84]:
tt.manual_viewbox=True
for i in range(15):
tt.sag = i*2
adjust_viewbox(corners, S, tt)
tt.save('./Shear_failure/beam')
tt
Out[84]:
In [85]:
for i in range(15):
tt.L_split=i*2/100
tt.split()
adjust_viewbox(corners, S, tt)
tt.save('./Shear_failure/beam')
tt
Out[85]:
In [27]:
# print(tt.svg_alt())
In [26]:
# from IPython.display import SVG
# SVG(tt.svg_alt())
In [25]:
with open("split.svg",'w') as f:
f.write(tt.svg_alt())
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]: