Determining the length change due to Shear Failure.

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$

$$T = \frac{M(x)}{\frac{2}{3} d} = \frac{-\frac{w x^2}{2} + \frac{w L}{2} x}{\frac{2}{3} d}$$
$$T = \frac{3}{2 d}\left(-\frac{w x^2}{2} + \frac{w L}{2} x \right)$$$$T = \frac{3}{4} \frac{w}{d} \left(-x^2 + L x \right)$$

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.

$$\sigma = \frac{T}{A} = \frac{T}{b \frac{d}{2}}$$$$\sigma = \frac{\frac{3}{4} \frac{w}{d} \left(-x^2 + L x \right)}{b \frac{d}{2}}$$
$$\sigma = \frac{3}{2} \frac{w}{b d^2} \left(-x^2 + L x \right)$$
$$\Delta L = \frac{1}{E}\int^x_0 \sigma(x) dx$$

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$$

$$\Delta L = \frac{3}{2E} \frac{w}{ b d^2} \int^{L/4}_0 -x^2 + L x dx$$
$$\Delta L = \frac{3}{2E} \frac{w}{ b d^2} \left| -\frac{x^3}{3} + L \frac{x^2}{2} \right|_0^{L/4}$$
$$\Delta L = \frac{3}{2E} \frac{w}{ b d^2} \left( -\frac{L^3}{3\times 4^3} + L \frac{L^2}{2\times 16} \right)$$
$$\Delta L = \frac{1}{2E} \frac{w}{b d^2} \left( -\frac{L^3}{64} + \frac{3 L^3}{32} \right)$$
$$\Delta L = \frac{1}{2E} \frac{w}{b d^2} \left( -\frac{L^3}{64} + \frac{6 L^3}{64} \right)$$$$\Delta L = \frac{5 w L^3}{128 E b d^2}$$

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}}$$

$$\frac{\Delta L}{\Delta} = \frac{\frac{1}{128 b d^2}}{\frac{L}{384 I}}$$
$$\frac{\Delta L}{\Delta} = \frac{384 I}{128 L b d^2}$$$$\frac{\Delta L}{\Delta} = \frac{3 I}{ L b d^2}$$

Since this is a rectangular section, $$\frac{\Delta L}{\Delta} = \frac{3 \frac{1}{12} b d^3}{ L b d^2}$$

$$\frac{\Delta L}{\Delta} = \frac{d}{4 L}$$

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

$$\Delta L\left(L_{split}\right) = \Delta \times L_{split} \times \frac{d}{ L^2} $$

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$$
$$\frac{d f(x)}{dx} = \frac{dy}{dx} = 2 a x + b$$$$dy = \left(2 a x + b\right)dx$$$$dL = \sqrt{dx^2 + dy^2}$$$$dL = \sqrt{dx^2 + \left(2 a x + b\right)^2 dx^2}$$$$dL = dx \sqrt{1 + \left(2 a x + b\right)^2}$$$$dL = dx \sqrt{1 + 4 a^2 x^2 + 4 a x b+b^2}$$
$$\int_{x_0}^{x} \sqrt{1 + 4 a^2 x^2 + 4 a x b+b^2} 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}$$
$$ \Delta_x =\frac{ \Delta L }{\sqrt{1 + 4a^2 x_0^2+4 a x_0 b+b^2}}$$$$ \Delta_x =\frac{ \Delta L }{m}$$
$$ x - x_0 =\frac{ \Delta L }{\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)
$$ x =\frac{ \Delta L }{\sqrt{1 + 4a^2 x_0^2+4 a x_0 b+b^2}} + x_0$$$$ y = a x^2 +b x+c$$

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


X_s, scale = (0.25, 0.1875)
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


What is the maximum number of versions of this beam do you want to save? [1000]
Saving first svg drawing to: ./Shear_failure/beam-000.svg
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


X_s, scale = (0.0, 0.0)
X_s, scale = (0.02, 0.0196)
X_s, scale = (0.04, 0.0384)
X_s, scale = (0.06, 0.05639999999999999)
X_s, scale = (0.08, 0.0736)
X_s, scale = (0.1, 0.09000000000000001)
X_s, scale = (0.12, 0.1056)
X_s, scale = (0.14, 0.12040000000000001)
X_s, scale = (0.16, 0.1344)
X_s, scale = (0.18, 0.1476)
X_s, scale = (0.2, 0.16000000000000003)
X_s, scale = (0.22, 0.1716)
X_s, scale = (0.24, 0.1824)
X_s, scale = (0.26, 0.19240000000000002)
X_s, scale = (0.28, 0.2016)
/home/damon/Documents/CODE/Programing/Python/IPython Notebook Folders (links)/SVG/New_Spline.py:44: RuntimeWarning: invalid value encountered in double_scalars
  m = (y3-y0)/(x3-x0)
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 [ ]: