{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Examples 3 -- Particle Equilibrium\n", "\n", "Contents:\n", "- [A. Object on a ramp](#A)\n", "- [B. Failure limit](#B)\n", "- [C. Simple spring](#C)\n", "- [D. Simple spring 2](#D) \n", "- [E. Multiple springs](#E) \n", "- [F. 3D equilibrium ](#F) \n", "- [G. 3D equilibrium (2)](#G) \n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from numpy import *\n", "dtr = pi/180 # factor for degree-to-radian conversion" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## A. Object on a ramp\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "x1,x2 = 0.8,3.9 # m; left-to-right\n", "y1,y2 = 1.6,2.1 # m; bottom, top\n", "W = 260.0 # N\n", "f = 3./4 # fraction of distance from D to E\n", "rBD = array(( x1, -y2 )) # m\n", "rBE = array(( x1+x2, -y1-y2 )) # m" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "verify that we have uperp correct:\n", " uperp= [0.37955636 0.92516862]\n", " uperp.uED= 0.0\n", " mag of uperp= 1.0\n" ] }, { "data": { "text/plain": [ "-41.53792694386491" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rED = rBD - rBE\n", "rEC = (1-f)*rED\n", "rBC = rBE + rEC\n", "uCB = -rBC / sqrt(sum(rBC**2))\n", "# find unit vector perp. to ramp (and upward)\n", "uED = rED / sqrt(sum(rED**2))\n", "uperp = array((uED[1],-uED[0]))\n", "print ('verify that we have uperp correct:')\n", "print (' uperp=',uperp)\n", "print (' uperp.uED=',dot(uperp,uED))\n", "print (' mag of uperp=',sqrt(sum(uperp**2)))\n", "arctan(uCB[1]/uCB[0])*180/pi" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Force balancing gives\n", "\n", "$$\\sum \\vec{F}_i = T_{ABC} \\hat{u}_{CB} - W\\hat{\\jmath} + R \\hat{u}_{perp} =0$$\n", "\n", "Now we have two equations and two unknowns $T_{ABC}$ and $R$." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.379556356256306*Rs - 0.748516935361959*Ts\n", " 0.925168618374746*Rs + 0.663115674280393*Ts - 260.0]\n" ] } ], "source": [ "import sympy as s\n", "# define symbolic variables:\n", "Ts,Rs = s.symbols('Ts,Rs')\n", "# construct the equation that equals zero:\n", "eq = Ts*uCB - W*array((0.,1)) + Rs*uperp\n", "print (eq)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{Ts: 104.517331348682, Rs: 206.116934320280}\n" ] } ], "source": [ "ss = s.solve( [eq[0],eq[1]], [Ts,Rs])\n", "print (ss)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## B. Failure limit\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "T_AB_lim = 270. # lb\n", "T_other_lim = 495. # lb\n", "F_EC_lim = 650. # lb\n", "uCD = array(( 12., 5)) / sqrt(12**2+5**2)\n", "uEC = array((-24., 7)) / sqrt(24**2+7**2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Need to solve two equations with two unknowns:\n", "\n", "$$-(W+F)\\hat{\\jmath} + F_{EC} \\hat{u}_{EC} + T_{CD} \\hat{u}_{CD} =0$$\n", "\n", "Where $F=\\tfrac{1}{2}W$. The $x$ components yield\n", "\n", "$$F_{EC} = - T_{CD} \\frac{u_{CDx}}{ u_{ECx}}$$\n", "\n", "And the $y$ components yield\n", "\n", "$$F_{EC} = \\frac{-T_{CD} u_{CDy} + \\tfrac{3}{2}W}{ u_{ECy}}$$\n", "\n", "Then\n", "\n", "$$-T_{CD} \\frac{ u_{CDx} }{ u_{ECx}} u_{ECy} = -T_{CD} u_{CDy} +\\tfrac{3}{2}W$$\n", "\n", "So\n", "\n", "$$T_{CD} = \\frac{ \\tfrac{3}{2}W }{ u_{CDy} - \\frac{ u_{CDx} }{ u_{ECx}} u_{ECy} }$$\n", "\n", "This along with the $x$ component equation give both unknowns." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "W = arange(100.,1e3,1)\n", "T_AB = 0.5*W\n", "T_CB = W\n", "T_CD = 1.5*W / (uCD[1]-uCD[0]*uEC[1]/uEC[0])\n", "F_EC = -T_CD*uCD[0]/uEC[0]" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'member force (lb)')" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from matplotlib.pyplot import *\n", "%matplotlib inline\n", "plot( W, T_AB, label= '$T_{AB}$', color='blue')\n", "plot( W, T_CB, label= '$T_{CB}$', color='red')\n", "plot( W, T_CD, label= '$T_{CD}$', color='green')\n", "plot( W, F_EC, label= '$F_{EC}$', color='cyan')\n", "# plot force limits:\n", "W_max = W[-1]\n", "plot( (0,W_max), (T_AB_lim,T_AB_lim), color ='blue', linestyle=\"--\")\n", "plot( (0,W_max), (T_other_lim,T_other_lim), color ='red', linestyle=\"--\")\n", "plot( (0,W_max), (T_other_lim,T_other_lim), color ='green', linestyle=\"--\")\n", "plot( (0,W_max), (F_EC_lim,F_EC_lim), color ='cyan', linestyle=\"--\")\n", "legend(loc='lower right')\n", "xlabel('load $W$ (lb)')\n", "ylabel('member force (lb)')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Looks like cable $CD$ will fail first. Solve for $W$ when $T_{CD}$ is set to equal its limit." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "largest weight W that may be lifted is 215.7692307692308 lb\n" ] } ], "source": [ "W_lim = T_other_lim/1.5 * (uCD[1]-uCD[0]*uEC[1]/uEC[0])\n", "print ('largest weight W that may be lifted is',W_lim,'lb')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## C. Simple spring\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "Q = 35. *dtr # theta, radians\n", "k = 23. # lb/ft\n", "X = 4.0 # ft\n", "La,Lb,Lc = X, 3, 5 # unstretched length, ft, for parts a,b,c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Solution will equal the vertical component of the spring force $\\vec{F}_s$." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "for unstretched length= 4.0 ft, vertical component of Fs= 11.650061370997058 lb\n", "for unstretched length= 3 ft, vertical component of Fs= 24.842319407071116 lb\n", "for unstretched length= 5 ft, vertical component of Fs= -1.5421966650770018 lb\n" ] } ], "source": [ "rAB = array(( -X, X*tan(Q) ))\n", "rAB_mag = sqrt(sum(rAB**2))\n", "uAB = rAB / rAB_mag\n", "# part a\n", "L0 = La # unstretched length, ft\n", "Fs = k*(rAB_mag - L0) * uAB # force (vector) of spring on A\n", "print ('for unstretched length=',L0,'ft, vertical component of Fs=',Fs[1],'lb')\n", "# part b\n", "L0 = Lb # unstretched length, ft\n", "Fs = k*(rAB_mag - L0) * uAB # force (vector) of spring on A\n", "print ('for unstretched length=',L0,'ft, vertical component of Fs=',Fs[1],'lb')\n", "# part c\n", "L0 = Lc # unstretched length, ft\n", "Fs = k*(rAB_mag - L0) * uAB # force (vector) of spring on A\n", "print ('for unstretched length=',L0,'ft, vertical component of Fs=',Fs[1],'lb')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## D. Simple spring 2\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "k = 229. # N/mm\n", "L0 = 343. # mm\n", "X = 209. # mm\n", "Y = 169. # mm" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "(a)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "compare hypontenuse 268.77871939571406 to unstretched length 343.0\n", "solution:\n", " vertical component of force P= 10686.99853591264 N\n", " force in AB (magnitude)= 13216.465645004388 N\n" ] } ], "source": [ "rCA = array((X,-Y))\n", "rCA_mag = sqrt(sum(rCA**2))\n", "print( 'compare hypontenuse',rCA_mag,'to unstretched length',L0)\n", "uCA = rCA / rCA_mag\n", "FCA = k*(L0-rCA_mag)*uCA # spring force (vector), N\n", "P = -FCA[1]\n", "TAB = -FCA[0]\n", "print ('solution:')\n", "print (' vertical component of force P=',P,'N')\n", "print (' force in AB (magnitude)=',abs(TAB),'N')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "(b) Assume the origin is at point $B$.\n", "\n", "Find the angle $\\theta$ between member $AB$ and the vertical with the law of cosines:\n", "\n", "$$L_0^2 = X^2 + Y^2 - 2XY \\cos \\theta$$\n", "\n", "$$\\theta = \\cos^{-1} \\frac{X^2 + Y^2 - L_0^2}{2XY} $$\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xA,yA= 160.10528038464116 mm, -134.34023668639054 mm\n" ] } ], "source": [ "Q = arccos( (X**2+Y**2-L0**2)/(2*X*Y) )\n", "xA = X*sin(Q)\n", "yA = X*cos(Q)\n", "print ('xA,yA=',xA,'mm,',yA,'mm')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## E. Multiple springs\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "mA,mB = 49., 84. # kg\n", "k1,k2,k3 = 104.,122.,145. # N/mm\n", "g = 9.81 # N/kg" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "Define upward to be the $+y$ direction. The free body diagrams of each mass are shown below. For diagram purposes, the spring forces are assumed to all be in extension; actual spring force directions may be opposite the vector directions shown. \n", "\n", "\n", "\n", "The values of $\\delta_A$ and $\\delta_B$ are considered positive when the displacement is as shown in the figure in the problem definition. Weight vectors are given by $\\vec{W}_A=-m_A g \\hat{\\jmath}$ and $\\vec{W}_B=-m_B g \\hat{\\jmath}$.\n", "\n", "Define the force by spring 1 on mass A as $\\vec{F}_{1A} = k_1 \\delta_A \\hat{\\jmath} $. This force is in the $\\hat{\\jmath}$ direction when $\\delta_A$ is positive (i.e., when spring 1 is extended).\n", "\n", "Define the force by spring 2 on mass A as $\\vec{F}_{2A} = k_2 (\\delta_A -\\delta_B ) \\hat{\\jmath} $. This force is in the $\\hat{\\jmath}$ direction when $\\delta_A>\\delta_B$ (i.e., when spring 2 is compressed).\n", "\n", "Define the force by spring 2 on mass B as $\\vec{F}_{2B} = -k_2 (\\delta_A -\\delta_B ) \\hat{\\jmath} $. This force is in the $-\\hat{\\jmath}$ direction when $\\delta_A>\\delta_B$ (i.e., when spring 2 is compressed).\n", "\n", "Define the force by spring 3 on mass B as $\\vec{F}_{3B} = k_3 \\delta_B \\hat{\\jmath} $. This force is in the $\\hat{\\jmath}$ direction when $\\delta_B$ is positive (i.e., when spring 3 is compressed).\n", "\n", "Now force sums in the $y$ direction yeild (for mass A and B, respectively)\n", "\n", "$$ k_1 \\delta_A + k_2 (\\delta_A -\\delta_B ) -m_A g = 0 $$\n", "\n", "\n", "$$ - k_2 (\\delta_A -\\delta_B ) + k_3 \\delta_B - m_B g = 0 $$\n", "\n", "This can be written in matrix form:\n", "\n", "$$\\begin{bmatrix}\n", "k_1+k_2 & -k_2\\\\ \n", "-k_2 & k_2+k_3\n", "\\end{bmatrix}\n", "\\begin{bmatrix} \\delta_A \\\\ \\delta_B \\end{bmatrix}=\n", "\\begin{bmatrix} m_A g \\\\ m_B g \\end{bmatrix}\n", "$$\n", "\n", "This is solved with a [linalg](http://docs.scipy.org/doc/numpy/reference/routines.linalg.html) routine as follows." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "CC = array((( k1+k2, -k2 ),\n", " ( -k2, k2+k3 ) ))\n", "SS = array(( mA*g, mB*g ))\n", "solution = linalg.solve(CC,SS)\n", "deltaA, deltaB = solution[0], solution[1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now the forces can be calculated as defined above." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "spring extensions (positive down):\n", " delta A= 5.034913766553743 mm\n", " delta B= 5.386889436402834 mm\n", "force supported by each spring (negative in compression):\n", " F1= 523.6310317215892 N\n", " F2= 42.94103172158913 N\n", " F3= -781.0989682784109 N\n" ] } ], "source": [ "print ('spring extensions (positive down):')\n", "print (' delta A=',deltaA,'mm')\n", "print (' delta B=',deltaB,'mm')\n", "print ('force supported by each spring (negative in compression):')\n", "print (' F1=',k1*deltaA,'N')\n", "print (' F2=',k2*(deltaB-deltaA),'N')\n", "print (' F3=',-k3*deltaB,'N')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## F. 3D equilibrium\n", "\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "x,y,z = 12.,6.,5. # ft\n", "W = 800. # lb" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Force sum:\n", "\n", "$$-W \\hat{k} + F_{AB} \\hat{u}_{AB} + F_{AC} \\hat{u}_{AC} + R \\hat{u}_\\perp = 0$$\n", "\n", "Symmetry requires that $ F_{AB}= F_{AC}=T$. So we have 3 equations and 2 unknowns ($T$ and $R$):\n", "\n", "$$-W \\hat{k} + T \\left (\\hat{u}_{AB} + \\hat{u}_{AC} \\right ) + R \\hat{u}_\\perp = 0$$" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "rAB = array(( x, -y, z))\n", "rAC = array((-x, -y, z))\n", "uAB = rAB/sqrt(sum(rAB**2))\n", "uAC = rAC/sqrt(sum(rAC**2))\n", "rperp = cross(uAC,uAB)\n", "uperp = rperp/sqrt(sum(rperp**2))\n", "uz = array((0.,0,1))" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "0.64018439966448*Rs - 0.838116354923494*Ts\n", "0.768221279597376*Rs + 0.698430295769578*Ts - 800.0\n" ] } ], "source": [ "import sympy as s\n", "# define symbolic variables:\n", "Ts,Rs = s.symbols('Ts,Rs')\n", "# construct the equation that equals zero:\n", "eq = -W*uz + Ts*(uAB+uAC) + Rs*uperp \n", "print (eq[0])\n", "print (eq[1])\n", "print (eq[2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is nothing going on the $x$ direction, so solve the other two equations." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "R= 614.5770236779007 lb\n", "F_AB=F_AC= 469.4367561729952 lb\n" ] } ], "source": [ "ss = s.solve( [eq[1],eq[2]], [Ts,Rs])\n", "T = float(ss[Ts])\n", "R = float(ss[Rs])\n", "print ('R=',R,'lb')\n", "print ('F_AB=F_AC=',T,'lb')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## G. 3D equilibrium (2)\n", "\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "WE = 50.0 # lb\n", "xD,yD = 5, 14 # in\n", "rOA = array(( 0., 0., 8. )) # in\n", "rOB = array(( 0., 6., 0. )) # in\n", "rOD = array(( xD, yD, 0. )) # in\n", "lAC = 5 # in" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "weight W= 64.16339310766821 lb\n" ] } ], "source": [ "rAB = rOB - rOA\n", "uAB = rAB / sqrt(sum(rAB**2))\n", "rAC = uAB * lAC\n", "rCD = rOD - (rOA + rAC)\n", "uCD = rCD / sqrt(sum(rCD**2))\n", "T = WE * uCD # force vector (in lb) on C from cable CDE\n", "Rx,Rz = -T[0], -T[2] # two components of the reaction force from bar\n", "Ry = -(Rx*uAB[0] + Rz*uAB[2])/uAB[1] # setting dot product R.uAB to zero yeilds Ry\n", "W = Ry + T[1]\n", "print ('weight W=',W,'lb')" ] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.1" } }, "nbformat": 4, "nbformat_minor": 1 }