diff options
22 files changed, 11301 insertions, 0 deletions
diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_10_Moments_of_Inertia.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_10_Moments_of_Inertia.ipynb new file mode 100644 index 00000000..c3e6cf59 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_10_Moments_of_Inertia.ipynb @@ -0,0 +1,394 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 10 Moments of Inertia" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 10.2 Page No 382 " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "I_x = 106666667.0 mm**(4)\n", + "\n", + "Solution 2\n", + "I_x = 106666667.0 mm**(4)\n" + ] + } + ], + "source": [ + "# Ex 10.2\n", + "from scipy import integrate\n", + "from __future__ import division\n", + "\n", + "# Calculation Solution 1\n", + "a = lambda y: (y**2)*(100-(y**2)/400)\n", + "I_x = round(integrate.quad(a, 0, 200)[0],0) #[millimeter**(4)]\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1\"\n", + "print\"I_x = \",(I_x),\"mm**(4)\\n\"\n", + "\n", + "# Calculation Solution 2\n", + "a = lambda x: (1/3)*(400*x)**(3/2)\n", + "I_x = round(integrate.quad(a, 0, 100)[0],0) #[millimeter**(4)]\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2\"\n", + "print\"I_x = \",(I_x),\"mm**(4)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 10.4 Page No 384" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "I_x = 0.0357 m**(4)\n", + "\n", + "Solution 2\n", + "I_x = 0.0357 m**(4)\n" + ] + } + ], + "source": [ + "# Ex 10.4\n", + "\n", + "from scipy import integrate\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Calculation Solution 1\n", + "a = lambda y: y**(2)*(math.sqrt(y)-y)\n", + "I_x = round(integrate.quad(a, 0, 1)[0],4) #[meter**(4)]\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1\"\n", + "print\"I_x = \",(I_x),\"m**(4)\\n\"\n", + "\n", + "# Calculation Solution 2\n", + "a = lambda x: (1/3)*(x**(3)-x**(6))\n", + "I_x = round(integrate.quad(a, 0, 1)[0],4) #[meter**(4)]\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2\"\n", + "print\"I_x = \",(I_x),\"m**(4)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 10.5 Page No 387" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I_x = 101148542.17 mm**(4)\n" + ] + } + ], + "source": [ + "# Ex 10.5\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Using Parallel Axis Theorem\n", + "# Circle\n", + "I_xc = (1/4)*math.pi*25**(4)+math.pi*25**(2)*75**(2) #[millimeter**(4)]\n", + "# Rectangle\n", + "I_xr = (1/12)*100*150**(3)+100*150*75**(2) #[millimeter**(4)]\n", + "# Let I_x be moment of inertia for composite area\n", + "I_x = -I_xc+I_xr #[millimeter**(4)]\n", + "\n", + "# Result\n", + "print\"I_x = \",(I_x),\"mm**(4)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 10.6 Page No 388" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I_x = 2900000000.0 mm**(4)\n", + "I_y = 5600000000.0 mm**(4)\n" + ] + } + ], + "source": [ + "# Ex 10.6\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Using Parallel axis theorem\n", + "# Rectangle A\n", + "I_xA = (1/12)*100*300**(3)+100*300*200**(2) #[millimeter**(4)]\n", + "I_yA = (1/12)*300*100**(3)+100*300*250**(2) #[millimeter**(4)]\n", + "# Rectangle B\n", + "I_xB = (1/12)*600*100**(3) #[millimeter**(4)]\n", + "I_yB = (1/12)*100*600**(3) #[millimeter**(4)]\n", + "# Rectangle D\n", + "I_xD = (1/12)*100*300**(3)+100*300*200**(2) #[millimeter**(4)]\n", + "I_yD = (1/12)*300*100**(3)+100*300*250**(2) #[millimeter**(4)]\n", + "I_x = I_xA+I_xB+I_xD #[millimeter**(4)]\n", + "I_y = I_yA+I_yB+I_yD #[millimeter**(4)]\n", + "\n", + "# Result\n", + "print\"I_x = \",(I_x),\"mm**(4)\"\n", + "print\"I_y = \",(I_y),\"mm**(4)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 10.8 Page No 394" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I_xy = -3000000000 mm**(4)\n" + ] + } + ], + "source": [ + "# Ex 10.8\n", + "\n", + "# Calculation\n", + "# Rectangle A\n", + "I_xyA = 0+300*100*(-250)*(200)\n", + "# Rectangle B\n", + "I_xyB = 0+0\n", + "# Rectangle D\n", + "I_xyD = 0+300*100*(250)*(-200)\n", + "# Let I_xy be product of inertia for entire cross section\n", + "I_xy = I_xyA+I_xyB+I_xyD\n", + "\n", + "# Result\n", + "print\"I_xy = \",(I_xy),\"mm**(4)\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 10.10 Page No 400" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I_y = 0.873 kg.m**(2)\n" + ] + } + ], + "source": [ + "# Ex 10.10\n", + "from scipy import integrate\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "rho = 5 #[milligram per meter cube]\n", + "\n", + "# Calculation \n", + "a = lambda y: ((5*math.pi)/2)*y**(8)\n", + "I_y = round(integrate.quad(a, 0, 1)[0],3) #[kg meter square]\n", + "\n", + "# Result\n", + "print\"I_y = \",(I_y),\"kg.m**(2)\"\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 10.11 Page No 403" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IO = 1.2 kg.m**(2)\n" + ] + } + ], + "source": [ + "# Ex 10.11\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "rho = 8000 #[kg meter**(2)]\n", + "t = 0.01 #[meter]\n", + "\n", + "# Calculation\n", + "# Disk\n", + "IOd = (1/2)*15.71*0.25**(2)+15.71*0.25**(2) #[kg meter**(2)]\n", + "# Hole\n", + "IOh = (1/2)*3.93*0.125**(2)+3.93*0.25**(2) #[kg meter**(2)]\n", + "IO = round(IOd-IOh,2) #[kg meter**(2)]\n", + "# Result\n", + "print\"IO = \",(IO),\"kg.m**(2)\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 10.12 Page No 404" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IO = 17.0 kg.m**(2)\n", + "IG = 8.0 kg.m**(2)\n" + ] + } + ], + "source": [ + "# Ex 10.12\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "W = 3 #[kilogram]\n", + "\n", + "# Calculation\n", + "# Rod OA\n", + "IOAO = (1/3)*W*(2**(2)) #[kg meter**(2)]\n", + "# Rod BC\n", + "IBCO = (1/12)*W*(2**(2))+W*(2**(2)) #[kg meter**(2)]\n", + "# Let IO be moment of inertia of pendulum about O\n", + "IO = round(IOAO+IBCO,1) #[kg meter**(2)]\n", + "ybar = ((1*W+2*W)/(3+3)) #[meter]\n", + "IG = IO-2*W*ybar #[kg meter**(2)]\n", + "\n", + "# Result\n", + "print\"IO = \",(IO),\"kg.m**(2)\"\n", + "print\"IG = \",(IG),\"kg.m**(2)\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_11__Virtual_Work.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_11__Virtual_Work.ipynb new file mode 100644 index 00000000..3ee3ef32 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_11__Virtual_Work.ipynb @@ -0,0 +1,214 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 11 Virtual Work" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 11.1 Page No 418" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta = 63.0 degrees\n" + ] + } + ], + "source": [ + "# Ex 11.1\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "theta = round(math.degrees(math.atan(98.1/50)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"theta = \",(theta),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 11.3 Page No 420" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xc = 0.981 m\n", + "Cx = 114.0 N\n" + ] + } + ], + "source": [ + "# Ex 11.3\n", + "import math\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "theta = 45 #[Degrees]\n", + "\n", + "# Calculation\n", + "coeff = [1, -1.2*math.cos(math.pi*theta/180), -0.13]\n", + "# Taking only the positive root\n", + "xc = round(np.roots(coeff)[0],3) #[meter]\n", + "Cx = round(((-120*math.cos(math.pi*theta/180))*(1.2*math.cos(math.pi*theta/180)-2*xc))/(1.2*xc*math.sin(math.pi*theta/180)),0) #[Newton]\n", + "\n", + "# Result\n", + "print\"xc = \",(xc),\"m\"\n", + "print\"Cx = \",(Cx),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 11.5 Page No 433" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta = 53.8 degrees\n", + "V1 = -29.4 (unstable equilibrium at theta = 0 degrees)\n", + "V2 = 46.9 (stable equilibrium at theta = 53.8 degrees)\n" + ] + } + ], + "source": [ + "# Ex 11.5\n", + "import math\n", + "from scipy.misc import derivative\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "W = 10*9.81 #[Newton]\n", + "k = 200 #[Newton per meter]\n", + "l = 0.6 #[meter]\n", + "\n", + "# Calculation\n", + "\n", + "# Let V1 = d**(2)V/dtheta**(2) at theta = 0 \n", + "def f1(x):\n", + " return (1/2)*k*(l**(2))*((1-math.cos(x))**(2))-(W*l/2)*(2-math.cos(x))\n", + "V1 = round(derivative(f1, 0*math.pi/180,dx=1e-6, n=2),1)\n", + "\n", + "# Let V2 = d**(2)V/dtheta**(2) at theta = 53.8 \n", + "def f2(x):\n", + " return (1/2)*k*(l**(2))*((1-math.cos(x))**(2))-(W*l/2)*(2-math.cos(x))\n", + "V2 = round(derivative(f2, 53.8*math.pi/180,dx=1e-6, n=2),1)\n", + " \n", + "# Result\n", + "print\"theta = \",(theta),\"degrees\"\n", + "print\"V1 = \",(V1),\"(unstable equilibrium at theta = 0 degrees)\"\n", + "print\"V2 = \",round(V2,1),\"(stable equilibrium at theta = 53.8 degrees)\" " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 11.6 Page No 434" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "m = 6.53 kg\n", + "V = -47.6 (unstable equilibrium at theta = 20 degrees)\n" + ] + } + ], + "source": [ + "# Ex 11.6\n", + "import math\n", + "from __future__ import division\n", + "from scipy.misc import derivative\n", + "\n", + "# Calculation\n", + "# From dV/dtheta at theta = 20 degrees\n", + "m = round(69.14/10.58,2) #[kilogram]\n", + "def f(x):\n", + " return 98.1*(1.5*math.sin(x)/2)-m*9.81*(1.92-math.sqrt(3.69-3.6*math.sin(x)))\n", + "\n", + "# Let V = d**(2)V/dtheta**(2) at theta = 20 degrees\n", + "V = round(derivative(f, 20*math.pi/180,dx=1e-6, n=2),1)\n", + "# Result\n", + "print\"m = \",(m),\"kg\"\n", + "print\"V = \",(V),\" (unstable equilibrium at theta = 20 degrees)\"\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_12_Kinematics_of_a_Particle.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_12_Kinematics_of_a_Particle.ipynb new file mode 100644 index 00000000..59332347 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_12_Kinematics_of_a_Particle.ipynb @@ -0,0 +1,1382 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 12 Kinematics of a Particle" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.1 Page No 450" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "s = 36.0 m\n", + "a = 20.0 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 12.1\n", + "from scipy import integrate\n", + "from scipy.misc import derivative\n", + "\n", + "# Calculation\n", + "# Position\n", + "t = lambda t: 3*t**2+2*t\n", + "s = round(integrate.quad(t, 0, 3)[0],1) #[meter]\n", + "# Acceleration\n", + "# a = dv/dt\n", + "def f(t):\n", + " return 3*t**2+2*t\n", + "a = round(derivative(f, 3),1) #[meter per seconds square]\n", + "\n", + "# Result\n", + "print\"s = \",(s),\"m\"\n", + "print\"a = \",(a),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.2 Page No 451" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v = 0.559 m/s\n", + "s = 4.43 m\n" + ] + } + ], + "source": [ + "# Ex 12.2\n", + "from scipy import integrate\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# At t = 4 s\n", + "v = round(((1/(60**(2))) +0.8*4)**(-0.5),3) #[meter per second]\n", + "# ds = vdt\n", + "t = lambda t: ((1/(60**(2))) +0.8*t)**(-0.5) \n", + "s = round(integrate.quad(t, 0, 4)[0],2) #[meter]\n", + "\n", + "# Result\n", + "print\"v = \",(v),\"m/s\"\n", + "print\"s = \",(s),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.3 Page No 452" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sB = 326.7 m\n", + "vC = 80.1 m\n" + ] + } + ], + "source": [ + "# Ex 12.3\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "vA = 75 #[meter per second]\n", + "aC = -9.81 #[meter per second square]\n", + "sA = 40 #[meter]\n", + "\n", + "# Calculation\n", + "# Maximum height\n", + "sB = round((-75**(2)/(2*-9.81))+40,1) #[meter]\n", + "# Velocity\n", + "# Method 1\n", + "vC = round(math.sqrt(0+2*(-9.81)*(0-327)),1) #[meter per second]\n", + "# Method 2\n", + "vC = round(math.sqrt(75**(2)+2*(-9.81)*(0-40)),1) #[meter per second]\n", + "\n", + "# Result\n", + "print\"sB = \",(sB),\"m\"\n", + "print\"vC = \",(vC),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.4 Page No 453" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vB = 346.4 mm/s\n", + "t = 0.658 s\n" + ] + } + ], + "source": [ + "# Ex 12.4\n", + "from scipy import integrate\n", + "\n", + "# Calculation\n", + "vB = round(2*(0.2**(2)-0.01)**(0.5)*1000,1) #[millimeter per second]\n", + "s = lambda s: (0.5)*(1/math.sqrt(s**(2)-0.01))\n", + "t = round(integrate.quad(s, 0.1, 0.2)[0],3) #[seconds]\n", + "\n", + "# Result\n", + "print\"vB = \",(vB),\"mm/s\"\n", + "print\"t = \",(t),\"s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.5 Page No 454" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sT = 14.1 m\n", + "v_avg = 1.75 m/s\n", + "vsp_avg = 4.03 m/s\n" + ] + } + ], + "source": [ + "# Ex 12.5\n", + "\n", + "# Calculation\n", + "# ds = vdt\n", + "# s = t**(3)-3*t**(2) m\n", + "\n", + "# Let s1 be displacement at t = 0 sec\n", + "s1 = 0**(3)-3*0**(2) #[meter] \n", + "\n", + "# Let s2 be displacement at t = 2 sec\n", + "s2 = 2**(3)-3*2**(2) #[meter] \n", + "\n", + "# Let s3 be displacement at t = 0 sec\n", + "s3 = 3.5**(3)-3*3.5**(2) #[meter] \n", + "\n", + "# Let sT be distance travelled in 3.5 sec\n", + "sT = round(abs(s2)+abs(s2)+abs(s3),1) #[meter] \n", + "\n", + "# Velocity\n", + "# Let delta_s be displacement from t = 0 to t = 3.5 s\n", + "delta_s = s3 - s1 #[meter] \n", + "\n", + "# let v_avg be average velocity\n", + "v_avg = delta_s/(3.5-0) #[meter per second] \n", + "\n", + "# Let vsp_avg be average speed defined in terms of distance travelled sT\n", + "vsp_avg = round(sT/(3.5-0),2) #[meter per second] \n", + "\n", + "# Result\n", + "print\"sT = \",(sT),\"m\"\n", + "print\"v_avg = \",(v_avg),\"m/s\"\n", + "print\"vsp_avg = \",(vsp_avg),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.6 Page No 460" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAGHCAYAAAD2qfsmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\njUFDkiSVxqAhSZJKY9CQJEml+f8r4uhfIgCjLgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x660cc90>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAAGHCAYAAAD/QltcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x64b49d0>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Ex 12.6\n", + "%matplotlib inline\n", + "from matplotlib.pyplot import plot,title,xlabel,ylabel,text,axis,show\n", + "\n", + "# Calculation\n", + "# v-t graph\n", + "plot(\n", + " [0,10,30],\n", + " [0,10,10],\n", + " color='b',linewidth = 2\n", + " ) \n", + "plot(\n", + " [0,10],\n", + " [10,10],\n", + " color='g',linestyle='--'\n", + " ) \n", + "plot(\n", + " [10,10],\n", + " [0,10],\n", + " color='g',linestyle='--'\n", + " ) \n", + "plot(\n", + " [30,30],\n", + " [0,10],\n", + " color='g',linestyle='--'\n", + " ) \n", + "text(2.6,5.8,'v = t',color='r')\n", + "text(15,10.2,'v = 10',color='r')\n", + "axis([0,40,0,20])\n", + "title('Plot of v-t')\n", + "xlabel('t(s)')\n", + "ylabel('v(m/s)')\n", + "show()\n", + "print\"\\n\\n\"\n", + "# a-t graph\n", + "plot(\n", + " [0,10],\n", + " [1,1],\n", + " color='b',linewidth = 2\n", + " ) \n", + "plot(\n", + " [10,30],\n", + " [0,0],\n", + " color='b',linewidth = 2\n", + " ) \n", + "plot(\n", + " [10,10],\n", + " [0,1],\n", + " color='g',linestyle='--'\n", + " )\n", + "axis([0,40,0,2])\n", + "title('Plot of a-t')\n", + "xlabel('t(s)')\n", + "ylabel('a(m/s**(2))')\n", + "show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 12.7 Page No 462" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGHCAYAAABiT1LUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x5ce2cf0>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAisAAAGHCAYAAABxmBIgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x5863e50>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Ex 12.7\n", + "%matplotlib inline\n", + "from matplotlib.pyplot import plot,title,xlabel,ylabel,text,axis,show\n", + "\n", + "# Calculation\n", + "# v-t graph\n", + "plot(\n", + " [0,10,60],\n", + " [0,100,0],\n", + " color='b',linewidth = 2\n", + " ) \n", + "plot(\n", + " [10,10],\n", + " [0,100],\n", + " color='g',linestyle='--'\n", + " ) \n", + "plot(\n", + " [0,10],\n", + " [100,100],\n", + " color='g',linestyle='--'\n", + " ) \n", + "text(0,95,'v = 10t',color='r')\n", + "text(30,66,'v = -2t + 120',color='r')\n", + "axis([0,80,0,150])\n", + "title('Plot of v-t')\n", + "xlabel('t(s)')\n", + "ylabel('v(m/s)')\n", + "show()\n", + "print\"\\n\\n\"\n", + "# s-t graph\n", + "l1 = []\n", + "l2 = []\n", + "for i in range(0,11,1):\n", + " l1.append(i)\n", + " l2.append(5*i**(2))\n", + "plot(\n", + " l1,\n", + " l2,\n", + " color='b',linewidth = 2\n", + " ) \n", + "l1 = []\n", + "l2 = []\n", + "for i in range(10,61,1):\n", + " l1.append(i)\n", + " l2.append(-(i**(2))+120*i-600)\n", + "plot(\n", + " l1,\n", + " l2,\n", + " color='b',linewidth = 2\n", + " ) \n", + "plot(\n", + " [10,10],\n", + " [0,500],\n", + " color='g',linestyle='--'\n", + " ) \n", + "plot(\n", + " [0,10],\n", + " [500,500],\n", + " color='g',linestyle='--'\n", + " )\n", + "plot(\n", + " [60,60],\n", + " [0,3000],\n", + " color='g',linestyle='--'\n", + " )\n", + "plot(\n", + " [0,60],\n", + " [3000,3000],\n", + " color='g',linestyle='--'\n", + " )\n", + "text(8,200,'s = 5t**(2)',color='r')\n", + "text(25,1500,'s = t**(2) + 120t - 600',color='r')\n", + "axis([0,80,0,3500])\n", + "title('Plot of s-t')\n", + "xlabel('t(s)')\n", + "ylabel('s(m)')\n", + "show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.8 Page No 464" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAAGHCAYAAAD/QltcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAAPYQAAD2EBqD+naQAAIABJREFUeJzt3XeYXVW9//H3FxJIaKEmhG4sIQkKZBBBpAkXRDoqEECu\nKNLkgkGvwFUh4FUsNOlFUAQZAalRf4CCRqRqgnjJBLjcUNQESARDKmnr98c6kynMJJMpe58z8349\nzzzJXmefc75nMWQ+s/Zaa0dKCUmSpCKsUnYBkiSp7zB4SJKkwhg8JElSYQwekiSpMAYPSZJUGIOH\nJEkqjMFDkiQVxuAhSZIKY/CQJEmFMXhIIiJ2j4ilEbFb2bU0FxGfjYgpEbEwIt4sux5JXWfwkHqx\niPj3SqBo/JofEc9HxOURMbjV6Z26f0JE7BcR53ZDua1fdzjwY+B/geOBE7r7PSrvc3ZEHNwTry3p\n3fqVXYCkHpeAbwIvAwOAjwEnA/tFxDYppQVdfP1PAqcA53XxdVrbAwjg9JTSS9382s39F3AHcG8P\nvoekCoOH1Dfcn1KaVPn7jZXLFmOBg4Hbuvja0cXnt2dI5c+3e+j1JZXASy1S3/QwOTC8Z3knRcRn\nIuLPETEvImZExM0RsUmzx39MHu2g2eWcJSt684g4JSKejYgFEfGPiLgiIgY1e/wlYFzlcEbldc9Z\nzusNiYgfR8TfKq85LSLuiYgtVlDHUmAN4HPN6r9xRfVL6jxHPKS+6X2VP//Z3gkR8TngRuBJ4Czy\nCMSXgY9GxPYppbeBa4BNgL2Bo+nA6EdEjAPOAR4ErgKGk8PLDhGxS0ppCXA68O/AIcCJwFzgr8t5\n2buAEcBlwCvAYODfgC2AV5fzvGOAGyqf8bpK2/+t6DNI6jyDh9Q3DIqIDWia4/FNYB7wy7ZOjoh+\nwHfJP+x3TyktrLQ/WnnOWOC8lNKTEfECsHdKqX5FRUTEhuQQc39K6ZPN2p8HLicHgZtSSvdFxPbk\n4HFnSqndFS2VkZKdga+mlC5u9tD3VlRPSunWiLgWmJpSunVF50vqOi+1SL1fAA8BM4C/AbeS500c\nklKa3s5zdiCPGlzVGDoAUkq/Bp4D9u9kLXsD/YFLW7VfD8zu5OvOBxYCe0TEup2sS1JBHPGQer9E\nvpTxv8Bi4PWU0vMreM6Wlee90MZjzwG7dLKWLSt/tnjdlNKiiJja7PEOSyktjIgzgQuB1yPiCfKo\nzE9TSq8DRMQ6wMBmT1uYUnqrMx9AUtc44iH1DX9KKT2cUvpDB0JHzUkp/RD4APkyznzgfGBKRGxb\nOeWHwPRmX3eWUackg4ektr1CvkQzvI3Hhlceb7QyG481Pq/F60ZEf/IKm1fe9YwOSim9lFK6JKX0\nCWAbYDXgK5WHv0e+zNP49ZXmT+3se0paeQYPSW35M/AGcFIlFAB5l1Ly6pHmk1LnVh5bpwOv+1tg\nEXBaq/bjgXVoZ7Lr8kTEwIhYvVXzS+Q5I6sDpJSeq4z4NH493ap+54ZIBXGOh9T7dXSDr2XnpZQW\nV+ZN3Aj8ISLqgY3JgWEqLSeHTqw89/KIeABYklJqc1OylNLMiLgAOCci7gfuA7Ym76T6FPCzlfpk\n2QeAhyLidqCBPI/lMPLk2BWutKnUv3dEjAWmAS+llJ7qRB2SOsDgIfV+Hb2U0OK8lNJNETGXPG/i\nu+SRgTuBsyp7eDS6i7x/xpE07eXR7m6oKaXzIuIN4FTgYuBN8n4gX6/s4bGyGlfq7EVejruYPAH2\nMymlezrw/DOAa4FvkSeg3kQOQZJ6QKTk5U1JklQM53hIkqTCGDwkSVJhDB6SJKkwBg9JklQYg4ck\nSSpMr1xOW7kL577Ay8CCcquRJKmmDAC2Ah5IKf2zu1+8VwYPcujozEZEkiQpO5q8R0636q3B42WA\nW265hREjRpRcSm0ZO3Ysl1xySdll1BT7rHPst5Vnn3WO/bZypkyZwjHHHAOVn6XdrbcGjwUAI0aM\nYPTo0WXXUlMGDRpkn60k+6xz7LeVZ591jv3WaT0yVcHJpZIkqTAGD0mSVBiDhyRJKozBQy2MGTOm\n7BJqjn3WOfbbyrPPOsd+qy698u60ETEamDhx4kQnFEmStBImTZpEXV0dQF1KaVJ3v74jHpIkqTAG\nD0mSVBiDhyRJKozBQ5IkFcbgIUmSCmPwkCRJhTF4SJKkwlRF8IiIXSPivoj4R0QsjYiDlnPuNZVz\nTiuyRkmS1HVVETyANYG/AKcA7e5oFhGHAh8B/lFQXZIkqRv1K7sAgJTS/cD9ABERbZ0TEZsCPwT2\nBX5dXHWSJKm7VMuIx3JVwshPge+nlKaUXY8kSeqcmggewFnAwpTSFWUXIkmSOq8qLrUsT0TUAacB\n26/sc8eOHcugQYNatI0ZM8Y7FUqSBNTX11NfX9+ibdasWT36nlV3d9qIWAocklK6r3J8OnARLSed\nrgosBV5NKQ1r4zW8O60kSZ3Q03enrfoRD/Lcjt+0anuw0v7j4suRJEmdVRXBIyLWBN4HNK5oGRYR\n2wJvppT+BrzV6vxFwGsppf8ttlJJktQVVRE8gB2A35EvpyTypRWAm4DPt3F+dV0fkiRJHVIVwSOl\nNIGVWGHT1rwOSZJU/WplOa0kSeoFDB6SJKkwBg9JklQYg4ckSSqMwUOSJBXG4CFJkgpj8JAkSYUx\neEiSpMIYPCRJUmEMHpIkqTAGD0mSVBiDhyRJKozBQ5IkFcbgIUmSCmPwkCRJhTF4SJKkwhg8JElS\nYQwekiSpMAYPSZJUGIOHJEkqjMFDkiQVxuAhSZIKY/CQJEmFMXhIkqTCGDwkSVJhDB6SJKkwBg9J\nklQYg4ckSSqMwUOSJBXG4CFJkgpTFcEjInaNiPsi4h8RsTQiDmr2WL+I+F5E/DUi5lTOuSkihpZZ\nsyRJWnlVETyANYG/AKcAqdVjawDbAecB2wOHAsOBe4ssUJIkdV2/sgsASCndD9wPEBHR6rG3gX2b\nt0XEqcCTEbFZSunvhRUqSZK6pFpGPFbWuuSRkX+VXYgkSeq4mgseEbE68F3g1pTSnLLrkSRJHVdT\nwSMi+gF3kEc7Tim5HEmStJKqYo5HRzQLHZsDH+/IaMfYsWMZNGhQi7YxY8YwZsyYnilSkqQaUl9f\nT319fYu2WbNm9eh7RkqtF5GUKyKWAoeklO5r1tYYOoYBe6aU3lzBa4wGJk6cOJHRo0f3aL2SJPUm\nkyZNoq6uDqAupTSpu1+/KkY8ImJN4H1A44qWYRGxLfAmMB24k7yk9gCgf0QMqZz3ZkppUdH1SpKk\nzqmK4AHsAPyOPHcjARdV2m8i799xYKX9L5X2qBzvCfyh0EolSVKnVUXwSClNYPkTXWtqEqwkSWqb\nP9AlSVJhDB6SJKkwBg9JklQYg4ckSSqMwUOSJBXG4CFJkgpj8JAkSYUxeEiSpMIYPCRJUmEMHpIk\nqTAGD0mSVBiDhyRJKozBQ5IkFcbgIUmSCmPwkCRJhTF4SJKkwhg8JElSYQwekiSpMAYPSZJUGIOH\nJEkqjMFDkiQVxuAhSZIKY/CQJEmFMXhIkqTCGDwkSVJhDB6SJKkwBg9JklQYg4ckSSqMwUOSJBXG\n4CFJkgpTFcEjInaNiPsi4h8RsTQiDmrjnPMjYlpEzIuI30TE+8qoVZIkdV5VBA9gTeAvwClAav1g\nRJwJnAqcAOwIzAUeiIjViixSkiR1Tb+yCwBIKd0P3A8QEdHGKacD30op/bJyzrHA68AhwO1F1SlJ\nkrqmWkY82hUR7wE2Bh5qbEspvQ08CexcVl1SLVi0qOwKJKmlqg8e5NCRyCMczb1eeUxSK0uWwGmn\nweGHw9KlZVcjSU2q4lJLT5kyYwpMb/uxAf0GMHKjkct9fsOMBhYsXtDu40PXGsrQtYe2+/j8RfOZ\nMnPKct9jxIYjGNh/YLuPT589nelz2vkQ+Dma83Nkc+fCd8aO4P5f5s9x5pnwgx8styRJKkwtBI/X\ngACG0HLUYwjw9PKeeMwJx8CAVo0fzF8jNxrJ5FMmL/eNP3PHZ2iY0dDu4+fufi7j9hjX7uNT35pK\n3XV1y32PZ09+llGDR7X7+LUTr+W8Cee1+7ifo4mfo5knn4W11id2vJZNhp8ItB9kJPVd9fX11NfX\nt2ibNWtWj75npPSuRSSlioilwCEppfuatU0DfpBSuqRyvA45hBybUrqjjdcYDUy85f5bGPGhEW2+\nTzX8Zgq94zds8HM0KvNzNDTAl78M//wnMGMEa71nCnOOrmPiCRMZPXT0cmuSpEaTJk2irq4OoC6l\nNKm7X78qgkdErAm8jzyyMQk4A/gd8GZK6W8R8TXgTOBzwMvAt4BRwKiU0sI2Xm80MHHixImMHu0/\nuOr97rkHjj4a5s3Lx+99L3z/5kl86kGDh6SV09PBo1outexADhqp8nVRpf0m4PMppe9HxBrAtcC6\nwCPAfm2FDqkvSQkuugi+9rX8d4BddslB5FVXtEiqQlURPFJKE1jBCpuU0jhgXBH1SLVg0SI49VS4\n7rqmtqOPhh/9CAYMgFfbvyIkSaWpheW0klqZNQv2379l6Bg3Dm6+OYcOSapWVTHiIanjXnoJDjgg\nTyYFWG01uPHGPNohSdXO4CHVkMcfh4MPhhkz8vEGG8Ddd8Ouu7773KFrDeXc3c9l6FoupZVUPQwe\nUo24/XY49lh45518/IEPwK9+Be9r5z7NQ9ceutz9QCSpDM7xkKpcSvDtb8MRRzSFjj33hCeeaD90\nSFK1csRDqmILF8IJJ8BNNzW1HXccXHNNntshSbXG4CFVqTffhMMOgwkTmtouuCDfeyWivLokqSsM\nHlIVevHFvFz2hRfy8YAB8NOfwmc+U25dktRVBg+pyjzyCBxySB7xABg8GO67Dz7ykXLrkqTu4ORS\nqYrcfDPstVdT6Bg1Cp580tAhqfcweEhVICU499y8XHZR5R4r++wDjz4KW23Vudecv2g+k9+YzPxF\n87utTknqKoOHVLIFC/Kuo+ef39R20kl5j45Bgzr/ulNmTmGbq7dhyswpXS9SkrqJczykEs2Ykedz\nPPZYPo6ACy+EsWNduSKpdzJ4SCV57rm8cmXq1Hy8xhpw6615S3RJ6q0MHlIJHnoIPv1p+Ne/8vHQ\noTB+PNTVlVuXJPU053hIBbvhBvjEJ5pCx7bb5pUrhg5JfYHBQyrI0qVw1llw/PGweHFu23//vG/H\n5puXW5skFcVLLVIB5s3LS2XvvLOp7fTT4aKLYNVVy6tLkopm8JB62Guv5QmjTz2Vj1dZBS67DL70\npXLrkqQyGDykHvTss/lyyquv5uO11oLbb4f99uv59x6x4QiePflZhq03rOffTJI6yOAh9ZAHHsg3\ndZs9Ox9vvjn88pfwoQ8V8/4D+w9k1OBRxbyZJHWQk0ulHnD11XmkozF07LBDXrlSVOiQpGpl8JC6\n0ZIledfRU07Jfwc47DCYMCHv1SFJfZ3BQ+omc+bAoYfCpZc2tf3nf8Idd+RdSSVJzvGQusU//gEH\nHghPP52PV101X2754hfLrUuSqo3BQ+qip5+GAw6AadPy8aBB8ItfwN57l1uXJFUjL7VIXTB+POy6\na1Po2GqrfKdZQ4cktc3gUY2uvBLe8x4YOBB22gn+9Kfln//aa3D00TB8eB7jP+OMts+bNSvvWrXJ\nJjBgAGy9Ndx//7vP23PPrn+GrvjrX+Goo2CLLfLkiFGj8o5bVSSlPJfj4INh7tzcttNOeeXKyJHl\n1tZo+uzpjPv9OKbPnl52KZK0jMGj2tx2G3zlK3DeeXkMf9ttYd99YebM9p/zzjsweDB885uw3XZt\nn7NoUf41/NVX4a674IUX4PrrYdNN8+OPPZZvmQoQkf986CF44omuf6YJE3KQ6qiJE2HIEPjZz6Ch\nAb7+dTj7bLjqqq7X0g0WL875bezYHEAAjjgCHn44/2eoFtPnTOe8CecxfY7BQ1L1MHgszwMP5HH0\n9daDDTfMswenTu3Z97zkEjjxxHxjj623hmuuyb/133hj+8/Zcsv8vGOOgXXWafucG27It0O95578\nq/kWW+TP9sEP5se32AKuuy7/RH377fzn9dc33b3sF7/Im1CssUbui332gfnzO/65GsNMRxx3XP48\nu+6ar10cdVRuu+uujr9GD3n77Tyf4+qrm9q+8Q249dY8QCVJWj6Dx/LMnZtHHyZNyr/OrrpqXi+5\nPBdcAGuv3f7XOuvA3//e9nMXLcq/7e+1V1NbRB6pePzxrn2W8eNh553zBhMbb5wDxwUX5FumAmy2\nWR5tGTQof9711oOf/zyPiLz2Wv7hf/zx8NxzeQTjsMOaft0vwqxZsP76xb1fG155BXbZJedRgP79\n4aab4FvfyvdfkSStWE2saomIVYDzgKOBjYFpwE9SSv/do2982GEtj3/0ozyW3tDQ/oX8k0/O4+7L\ns8kmbbfPnJl3nRoypGX7kCHw/PMdq7k9U6fm8HTMMfD//h+8+GKudfHifIlm2rQcstZfH+rq4K23\nYMwYuPjiHDyWLMmhq3EEZNRKbMXd1YDy2GP5Bie//nXXXqcLnnoKDjoIXn89H6+/Ptx9N+y2W2kl\nSVJNqongAZwFnAgcCzQAOwA/iYh/pZSu6LF3ffFFOOecPGNw5sw8OhCR50m0FzzWXTd/VZulS3OA\nue66/Bm23z6PvFx4YQ4eL7+cN534+Mfz5NIrr8xB5eWX4SMfye3bbJPnm+yzD3z608v/nGuvnd8n\npRxaFi7MbZDbjzmmY3M2nn0WDjkExo1rORJUoDvvzOUuWJCP3//+fM+VD3yglHIkqabVSvDYGbg3\npdS4BOPViDgK2LFH3/WAA/KkyB/9KI9SLF2af9NfuLD951xwAXznO+0/HpFHTDbb7N2PbbhhvpzT\n+Gt1o9dfz5dHumLoUFhttZZzLUaMyKMZixfDRz/askbIYaPRb36TL/c8+CBcfnme2PDkk3l+SVue\neabp7088AWedlS/RNI5+tDcXpbmGhnyZ6aST8uTSgqUEP/gBnHlmU9tuu+WpJhtsUHg5ktQrdDp4\nRMQWwJbAGsAMYHJK6Z3uKqyVx4AvRsT7U0r/GxHbArsAY3vo/eDNN/PKjxtuyBf2Af74xxU/ryuX\nWvr3z5c5Hnooj+tD/un30ENw2mkdr70tu+wC9fUt255/PgeSfq2+DR5+uO3X2Hnn/PXNb+bAcffd\n8OUvt33usGa3Yv/b3/J7rMzKlsmT8wjHccfB+ed3/HndZOHCPB3mhhua2o49Ng8Yrb564eVIUq+x\nUsEjIrYCTgaOBDYDmi9VWBgRjwDXAXemlJZ2U40A3wXWAZ6LiCXkSbFfTyn9vBvfo6X11su/1l53\nXR5teOWV/Fv3ilZndPVSyxlnwOc+lwPIjjvm1R3z5uW2Rv/1X3mP7ptuamp75pkcUubMgRkz8vFq\nq+VRDciB6Morc4D5j//IoeqCC9oPDs099VQOP/vsk+e4PPFEvvTUUxtWPPtsHm3Zb79cX+MI0Kqr\n5lGhHvbWW/lKUvP8df75eZBnZRbnlG1AvwGM3GgkA/oNKLsUSVqmw8EjIi4D/h14APgG8BR5kud8\nYH1gG2BX4Hzg3Ig4LqW0gp2vOuwI4Chy4GkAtgN+GBHTUko3t/eksWPHMmjQoBZtY8aMYcyYMSt+\nx4i8yuO00/IKkOHD8yZWe+zRhY/RAYcfnn+on3NO/oG73XZ5GcVGGzWdM316HkVobvvtm34qTpqU\n13duuWXT8t/NNsuvM3Zs3htk003z37/2tRXXtM468Ic/wA9/mNeTbrllnnS6zz7d85lbu/NO+Oc/\n4ZZb8lej5p+nh0ydmm9n/9xz+Xj11eEnP4Ejj+zRt+0RIzcayeRTJpddhqQqVl9fT32r0fBZs2b1\n6HtG6uCKg4i4ALgwpfTPDpz7CWCNlFK3bLwQEa8CF6SUrm7W9nXg6JTSu37tjojRwMSJEycyevTo\n7ihBfcCjj+Z5rI17tW20Edx7b766JEl9xaRJk6irqwOoSylN6u7X7/CIR0qpw7P7mk0C7S5rAEta\ntS3FfUjUTW69NU8naZw3PGJEXrnSfKqKJKnrauUH93jgGxHxyYjYMiIOJU8sLX8rS9W0lPL8jaOP\nbgode+2Vtw4xdEhS9+vUqpaI2IA8l2NPYDCtAkxKqbu3mDwV+BZwZeX9pgFXV9qkTnnnnbwZa/Np\nJMcfn7cX6d+/vLokqTfr7HLam4H3ATcArwM9und2SmkucEblS+qymTPzRqzNV0h///vw1a/W1soV\nSao1nQ0euwIfSyk9s8IzpSrz/PN55cr//V8+Hjgwj3q03iFfktT9Ohs8ngO8F6dqzu9/nwPGW2/l\n4403hvvugw9/uNSyJKnP6Ozk0lOAb0fE7hGxQUSs0/yrOwuUustPfpK3HmkMHR/8YN71vbeGjoYZ\nDYy6ahQNMxrKLkWSlunsiMe/yDuJtt5bO8jzPVbtSlFSd1q6NO/y3vwWOvvtBz//ecduGVOrFixe\nQMOMBhYsXlB2KZK0TGeDx8+AReTdRHt8cqnUWfPn593mb7+9qe1LX4JLL333LWokST2vs//0bgNs\nn1J6vjuLkbrT66/nnUifeCIfr7JKvvVNV++3J0nqvM4Gjz8DmwMGD1WlyZPhgAPg5Zfz8Zpr5ksr\nBxxQalmS1Od1NnhcTr5J2w+A/yFfdlkmpfTXrhYmddZvfpPvLvv22/l4003z9ufbbVduXZKkzgeP\n2yp/3tisLeHkUpXsuuvglFNgSeXOPqNHw/jxsMkm5dYlSco6Gzze061VSF20ZAmceSZcdFFT20EH\n5Zu/rblmeXVJklrqVPBIKb3S3YVInTV3LhxzDNxzT1PbGWfkLdBX7cNjb0PXGsq5u5/L0LWGll2K\nJC3T4eARETullJ7o4LlrAO9JKU3udGVSB0yblkc2Jk7Mx6uuCldcASedVG5d1WDo2kMZt8e4ssuQ\npBZWZufSmyPigYj4TES0OXgdESMj4jvA/wF13VKh1I5nnoGPfKQpdKyzDvz614YOSapmK3OpZSRw\nMvDfwK0R8QL59vQLgPWArYG1gLuBfVJK/9PNtUrL/OpXcOSRMGdOPt5yy7xyZZttyq1LkrR8HQ4e\nKaVFwGXAZRGxA/AxYEvyzeKeAS4BfpdSerMnCpUaXX45fPnLeSt0yKMe994LQ4aUW5ckacU6u6pl\nMtCQUpoHEBFbAocCOwAPdlNtUguLF8PYsXkOR6PPfAZuuinf2l6SVP06e3fae4FjASJiXeBJ4CvA\nvRFxcjfVJi0zezYcfHDL0HH22Xk3UkOHJNWOzgaP0cAjlb9/mnyjuC3JYcQ7Yahb/e1v8LGP5Ymj\nkG/uduON+W6zq3T2O1iSVIrO/rO9BjC78vd9gLtSSkuBJ8gBROoWEyfmORx/rWzCv+668OCDcNxx\n5dZVC+Yvms/kNyYzf9H8skuRpGU6GzxeBA6JiM2BfWma1zEYeLs7CpPuuQd22w2mT8/Hw4blO83u\nuWe5ddWKKTOnsM3V2zBl5pSyS5GkZTobPM4HLgReBp5MKT1ead8HeLob6lIfllLe+vyww2DevNy2\nyy7w5JMwfHi5tUmSuqazW6b/IiL+CAwlL6Vt9BB5Hw+pUxYtgv/4D7j22qa2o4+GG26A1Vcvry5J\nUvfo7HJaUkqvAa+1anuqyxWpz5o1Ky+P/c1vmtrGjYNzzoGI0sqSJHWjTgcPqTu9/DLsvz80NOTj\n1VbLK1eOPrrUsiRJ3czgodI98UTeo+ONN/LxBhvkiaUf+1i5dUmSup+7IKhUt9+eV6k0ho7hw/Mk\nUkOHJPVOBg+VIqW8AdgRR8CCBbltjz3g8cfhve8ttTRJUg/yUosKt3AhnHgi/OQnTW3HHQfXXJPn\ndqh7jNhwBM+e/CzD1htWdimStIzBQ4V68828P8eECU1tF1wAZ57pypXuNrD/QEYNHlV2GZLUgsFD\nhXnxxbxy5YUX8vGAAfDTn+YltJKkvqFm5nhExCYRcXNEzIyIeRHxTESMLrsudcwjj+R7rjSGjsGD\n4fe/N3RIUl9TEyMeEbEu8Ch5Z9R9gZnA+4G3yqxLHXPLLfCFL+S5HQCjRsEvfwlbbVVqWZKkEtRE\n8ADOAl5NKR3frO2VsopRx6SUdx49//ymtn32yUtoBw0qrSxJUolq5VLLgcCfI+L2iHg9IiZFxPEr\nfJZKs2BB3nW0eeg48cQ80mHokKS+q1aCxzDgZOB58h1wrwYui4jPllqV2jRjBuy9N9TX5+MIuPhi\nuPpq6N+/3NokSeWqleCxCjAxpfTNlNIzKaXrgeuBk0quS6089xzstBM8+mg+XmMNuPtuGDvW5bJF\nmz57OuN+P47ps6eXXYokLVMrczymA1NatU0BDlvek8aOHcugVuP6Y8aMYcyYMd1bnQB4+GH41Kfg\nX//Kx5tsAuPHw2jXHpVi+pzpnDfhPA4afhBD1x5adjmSqlB9fT31jcPTFbNmzerR96yV4PEoMLxV\n23BWMMH0kksuYbQ/9Qpx4415Dsfixfl4223zfI7NNiu3LklS+9r6ZXzSpEnU1dX12HvWyqWWS4Cd\nIuLsiHhvRBwFHA9cUXJdfd7SpXDWWXm5bGPoOOAA+OMfDR2SpHerieCRUvozcCgwBvgf4OvA6Sml\nn5daWB83bx4cfjh873tNbaedlm9pv9Za5dUlSapetXKphZTSr4Ffl12Hstdeg4MPhqeeyserrAKX\nXQZf+lK5dUmSqlvNBA9Vj2efzfdcefXVfLzWWnlTsP32K7cuSVL1q4lLLaoeDzwAH/1oU+jYfPO8\ndNbQIUnqCIOHOuzqq/NIx+zZ+XiHHeDJJ+FDHyq3LrVtQL8BjNxoJAP6DSi7FElaxkstWqElS+Cr\nX4VLL21qO+wwuPnmvEGYqtPIjUYy+ZTJZZchSS044qHlmjMHDj20Zej42tfgjjsMHZKkleeIh9r1\n97/DgQfCX/6Sj/v1g6uugi9+sdy6JEm1y+ChNj39dN4IbNq0fDxoEPziF/nmb5IkdZaXWvQu48fD\nrrs2hY6ttoLHHjN0SJK6zuChZVLKczkOPhjmzs1tO+2UV66MHFlubZKk3sHgISDfZ+XUU/Pt61PK\nbUccke+nmM8jAAAVSklEQVQ4O3hwubVJknoPg4d4++08ifSqq5ravv51uPVWGDiwvLokSb2PwaOP\ne+UV2GUXuP/+fNy/P9x0E/z3f+f7r6h2NcxoYNRVo2iY0VB2KZK0jKta+rA//SmPdLz+ej5ef324\n+27Ybbdy61L3WLB4AQ0zGliweEHZpUjSMv5O20fddRfsvntT6Hjf++CJJwwdkqSeZfDoY1KC738f\nPvUpmD8/t+22Ww4d739/ubVJkno/g0cfsmhR3nX0zDOb2j77WXjwQdhgg/LqkiT1HQaPPuKtt+AT\nn4Abbmhq+9a38kTS1Vcvry5JUt/i5NI+YOrUfDv7557Lx6uvDj/+MYwZU25dkqS+x+DRyz32WN6J\ndObMfLzhhnDvvfDRj5ZblySpb/JSSy9WXw8f/3hT6Nh667z9uaGjbxi61lDO3f1chq41tOxSJGkZ\ng0cvlFKev3HUUfDOO7ltr73g8cdh2LBya1Nxhq49lHF7jGPo2gYPSdXDSy29zDvv5JUrN9/c1PaF\nL8DVV+ddSSVJKpPBoxeZORMOOwweeaSp7Xvfg//8T4gory5JkhoZPHqJF17IK1defDEfDxwIt9yS\ng4gkSdXC4NELTJgAhx6a9+oA2HhjuO8++PCHy61LkqTWnFxa4266Cf7t35pCxwc/mFeuGDokSdXI\n4FGjli6Fb3wDPve5vBU65J1J//hH2GKLUkuTJKldBo8aNH9+Xir77W83tZ1yCowfD+usU15dqi7z\nF81n8huTmb9oftmlSNIyBo8a88YbeVOw227LxxFw6aVwxRXQzxk7ambKzClsc/U2TJk5pexSJGkZ\nf1TVkIaGvHLl5Zfz8Zpr5t1JDzyw1LIkSeqwmhzxiIizImJpRFxcdi1F+c1vYOedm0LHppvm/ToM\nHZKkWlJzwSMiPgycADxTdi1Fuf562G8/ePvtfLz99nnlyvbbl1uXJEkrq6aCR0SsBdwCHA/8q+Ry\netzSpXnX0RNOgCVLcttBB+WRjk03Lbc2SZI6o6aCB3AlMD6l9HDZhfS0uXPh05+GCy9sajvjDLjr\nrjy3Q5KkWlQzk0sj4khgO2CHsmvpadOm5ZGNiRPz8aqrwuWXw8knl1uXJEldVRPBIyI2Ay4F9k4p\nLSq7np70zDNwwAHw97/n47XXhjvugH33LbcuSZK6Q6SUyq5hhSLiYOAuYAnQeJ/VVYFUaVs9Nfsg\nETEamLjbbrsxaNCgFq81ZswYxowZU0jdK+vXv4YjjoA5c/LxFlvAr34F22xTbl2qTfMXzWfqW1MZ\ntt4wBvYfWHY5kqpQfX099fX1LdpmzZrFH/7wB4C6lNKk7n7PWgkeawJbtmr+CTAF+G5KaUqr80cD\nEydOnMjo0aOLKbKLrrgCTj89TygF2HFHuPfefMM3SZKKMmnSJOrq6qCHgkdNXGpJKc0FGpq3RcRc\n4J+tQ0etWbIExo7NczgaffrT8NOf5lvbS5LUm9Taqpbmqn+oZgVmz4aDD24ZOs4+O2+HbuiQJPVG\nNTHi0ZaU0sfLrqEr/va3vOvoM5Vt0Pr1g2uvhc9/vty6JEnqSTUbPGrZxIk5dEyfno/XXRfuvDPf\n/E2SpN6sli+11KR77oHddmsKHcOGweOPGzokSX2DwaMgKcFFF8Fhh8G8ebltl13yPVe23rrc2iRJ\nKorBowCLFuVdR7/61RxAAI46Cn77W9hww3JrU+81ffZ0xv1+HNNnTy+7FElaxuDRw2bNgv33zxNH\nG517LtxyCwwYUF5d6v2mz5nOeRPOY/ocg4ek6uHk0h700kt5+/OGyg4kq60GN94IRx9dbl2SJJXF\n4NFDnngi79Hxxhv5eIMN8sTSj32s3LokSSqTl1p6wG23wR57NIWO4cPzJFJDhySprzN4dKOU4Dvf\ngSOPhHfeyW177pmXy773veXWJklSNfBSSzdZuBBOOAFuuqmp7bjj4Jpr8twOSZJk8OgWb76Z9+eY\nMKGp7TvfgbPOgojy6pIkqdoYPLroxRfzctkXXsjHAwbkO8t+5jPl1iUN6DeAkRuNZEA/121Lqh4G\njy545BE45JA84gEweDDcey/stFO5dUkAIzcayeRTJpddhiS14OTSTrrlFth776bQMXJkXrli6JAk\nqX0Gj5WUUt559LOfzRNKAf7t3+Cxx2CrrUotTZKkquellpWwYAF8/vNQX9/UduKJcPnl0L9/eXVJ\nklQrDB4dNGNGns/x2GP5OAIuvBDGjnXliiRJHWXw6IDnnssrV6ZOzcdrrAG33pq3RJckSR1n8FiB\nhx+GT30K/vWvfDx0KIwfD3V15dYlSVItcnLpctx4I+y7b1Po2HZbeOopQ4ckSZ1l8GjD0qV519Ev\nfAEWL85t+++f9+3YbLNya5M6qmFGA6OuGkXDjIayS5GkZbzU0sq8eXDssXDnnU1tp50GF18Mq65a\nXl3SylqweAENMxpYsHhB2aVI0jIGj2Zeew0OOgj+9Kd8vMoq8MMfwqmnlluXJEm9hcGj4tln8+WU\nV1/Nx2utBbfdBp/8ZLl1SZLUmxg8gAceyDd1mz07H2++Ofzyl/ChD5VblyRJvU2fn1x6zTV5pKMx\ndNTV5XuuGDokSep+fTZ4LFkCZ5wBJ5+c/w5w6KEwYULeq0OSJHW/Phk85szJIeOSS5ravvpV+MUv\nYM01y6tL6lOuvBLe8x4YODDf1rlxVrekXq3PBY9//AN22y3vPgp5iex118EPfpBXsUi9xdC1hnLu\n7ucydK0qHMK77Tb4ylfgvPPg6afz7nz77gszZ5ZdmaQe1qd+1D79NOy4Y/4TYNAguP9++OIXy61L\n6glD1x7KuD3GMXTtFQSPBx6AXXeF9daDDTeEAw9sujFRT7nkknxr52OPha23zpOt1lgjbxcsqVfr\nM8Fj/Pj8b+u0afl4q63ynWb33rvUsqTyzZ2bRx8mTco3J1p11XwtcnkuuADWXrv9r3XWgb//ve3n\nLloEEyfCXns1tUXk/xkff7z7PpekqlQTy2kj4mzgUGBrYD7wGHBmSumFFT03pbwJ2Bln5L8D7Lwz\n3HMPDB7cg0VLteKww1oe/+hH+X+OhgYYObLt55x8MhxxxPJfd5NN2m6fOTPP6B4ypGX7kCHw/PMd\nq1lSzaqJ4AHsClwO/Jlc8wXAgxExIqU0v70nLV6cdx296qqmtiOOgB//OM9nkwS8+CKcc05eRz5z\nZr5ZUUTeTa+94LHuuvlLklZSTQSPlFKL/UMj4nPAG0Ad8Mf2nvflL7ccuf361+H8851EKrVwwAF5\ndcmPfpRHKZYuhVGjYOHC9p9zwQXwne+0/3hEHjFp666KG26YL+e8/nrL9tdfh4037txnkFQzaiJ4\ntGFdIAFvLu+kxtDRvz9cfz38+7/3fGFSTXnzTXjhBbjhBthll9z2x3azfJOuXGrp3z/v1PfQQ/nm\nSJCvgz70UL4jo6RereaCR0QEcCnwx5TSCu/3vf76cNddsPvuPV+bVHPWWw822CCvKd94Y3jlFTj7\n7DxisTxdvdRyxhnwuc/lALLjjnmVy7x5uU1Sr1ZzwQO4ChgJ7LKiEwcMGMt22w3ioovgooty25gx\nYxgzZkzPVihVgfmL5jP1rakMW28YA/u3M6kpIu+pcdpp8MEPwvDhcNllsMcePVvc4Yfn+STnnJMv\nsWy3XV7Wu9FGPfu+klqor6+nvr6+RdusWbN69D0jNS71qAERcQVwILBrSunV5Zw3Gpj40EMT+fjH\nRxdWn1RNJk2fRN11dUw8YSKjh/r/gaSOmTRpEnV1dQB1KaVJ3f36NTPiUQkdBwO7Ly90NOeke0mS\nqktNBI+IuAoYAxwEzI2Ixg0AZqWUFpRXmSRJWhm1srD0JGAd4PfAtGZfh5dYkyRJWkk1MeKRUqqV\ngCRJkpbDH+iSJKkwBg9JklQYg4ckSSpMTczxkLTyRmw4gmdPfpZh6w0ruxRJWsbgIfVSA/sPZNTg\nUWWXIUkteKlFkiQVxuAhSZIKY/CQJEmFMXhIkqTCGDwkSVJhDB6SJKkwBg+pl5o+ezrjfj+O6bOn\nl12KJC1j8JB6qelzpnPehPOYPsfgIal6GDwkSVJhDB6SJKkwBg9JklQYg4ckSSqMwUOSJBXG4CFJ\nkgpj8JB6qQH9BjByo5EM6Deg7FIkaZl+ZRcgqWeM3Ggkk0+ZXHYZktSCIx6SJKkwBg9JklQYg4ck\nSSqMwUOSJBXG4CFJkgpj8JAkSYUxeEiSpMIYPKReqmFGA6OuGkXDjIayS5GkZQweUi+1YPECGmY0\nsGDxgrJLkaRlaip4RMSXIuKliJgfEU9ExIfLrqm3qa+vL7uEmmOfdY79tvLss86x36pLzQSPiDgC\nuAg4F9geeAZ4ICI2LLWwXsb/QVeefdY59tvKs886x36rLjUTPICxwLUppZ+mlJ4DTgLmAZ8vtyxJ\nktRRNRE8IqI/UAc81NiWUkrAb4Gdy6pLkiStnJoIHsCGwKrA663aXwc2Lr4cSZLUGf3KLqCHDACY\nMmVK2XXUnFmzZjFp0qSyy6gp1dpnnzppCmwPe+02hf6zyq7m3WbNmsXgwdXXb9XMPuucWbNmMXLk\nJG65pexKakOzn50DeuL1I1+xqG6VSy3zgE+llO5r1v4TYFBK6dBW5x8F/KzQIiVJ6l2OTind2t0v\nWhMjHimlRRExEdgLuA8gIqJyfFkbT3kAOBp4GXATA0mSOm4AsBX5Z2m3q4kRD4CIOBz4CXk1y1Pk\nVS6fBrZOKc0osTRJktRBNTHiAZBSur2yZ8f5wBDgL8C+hg5JkmpHzYx4SJKk2lcry2klSVIvYPCQ\nJEmF6ZXBw5vJtS8izo6IpyLi7Yh4PSLujogPtHHe+RExLSLmRcRvIuJ9ZdRbjSLirIhYGhEXt2q3\nz1qJiE0i4uaImFnpl2ciYnSrc+y3iohYJSK+FRFTK/3xYkR8o43z+nSfRcSuEXFfRPyj8v/iQW2c\ns9w+iojVI+LKyvfm7Ij4RUQMLu5TFG95/RYR/SLiexHx14iYUznnpogY2uo1utxvvS54eDO5FdoV\nuBz4CLA30B94MCIGNp4QEWcCpwInADsCc8l9uFrx5VaXSog9gfx91bzdPmslItYFHgXeAfYFRgBf\nAd5qdo791tJZwInAKcDWwNeAr0XEqY0n2GcArEleYHAK8K6Jih3so0uB/YFPAbsBmwB39mzZpVte\nv60BbAecR/7ZeSgwHLi31Xld77eUUq/6Ap4AftjsOIC/A18ru7Zq/CJvR78U+FiztmnA2GbH6wDz\ngcPLrrfkvloLeB74OPA74GL7bLn99V1gwgrOsd9a9sd44PpWbb8AfmqftdtnS4GDWrUtt48qx+8A\nhzY7Z3jltXYs+zOV1W9tnLMDsATYrDv7rVeNeHgzuU5Zl5x83wSIiPeQ73/TvA/fBp7EPrwSGJ9S\nerh5o33WrgOBP0fE7ZXLepMi4vjGB+23Nj0G7BUR7weIiG2BXYBfV47tsxXoYB/tQN5Oovk5zwOv\nYj821/jz4V+V4zq6od9qZh+PDlrezeSGF19Odavs/nop8MeUUkOleWPyN5o35GsmIo4kD0Pu0MbD\n9lnbhgEnky99fps85H1ZRLyTUroZ+60t3yX/VvlcRCwhXw7/ekrp55XH7bMV60gfDQEWVgJJe+f0\naRGxOvn78daU0pxK88Z0Q7/1tuChlXMVMJL8G5XaERGbkQPa3imlRWXXU0NWAZ5KKX2zcvxMRGxD\n3n345vLKqmpHAEcBRwIN5LD7w4iYVglrUo+LiH7AHeQAd0p3v36vutQCzCRfjxrSqn0I8Frx5VSv\niLgC+CSwR0pperOHXiPPi7EPm9QBGwGTImJRRCwCdgdOj4iF5LRvn73bdKD1LaKnAFtU/u732rt9\nH/huSumOlNLklNLPgEuAsyuP22cr1pE+eg1YLSLWWc45fVKz0LE5sE+z0Q7opn7rVcGj8tto483k\ngBY3k3usrLqqTSV0HAzsmVJ6tfljKaWXyN9AzftwHfIqmL7ah78FPkj+7XPbytefgVuAbVNKU7HP\n2vIo777EORx4Bfxea8ca5F+emltK5d9q+2zFOthHE4HFrc4ZTg7FjxdWbJVpFjqGAXullN5qdUr3\n9FvZM2t7YKbu4cA84FjycrRrgX8CG5VdWzV8kS+vvEVeVjuk2deAZud8rdJnB5J/4N4D/C+wWtn1\nV8sX717VYp+9u492IM+APxt4L/kSwmzgSPut3T77MXmi3ieBLclLGt8AvmOfteinNcm/AGxHDmZf\nrhxv3tE+qvxb+BKwB3lU81HgkbI/W1n9Rp56cS/5F4MPtvr50L87+630juihzj0FeJm8fOpxYIey\na6qWr8o325I2vo5tdd448pK0eeRbI7+v7Nqr6Qt4uHnwsM/a7adPAn+t9Mlk4PNtnGO/NfXFmsDF\nlX/Y51Z+WJ4H9LPPWnz+3dv5t+zGjvYRsDp5T6OZ5EB8BzC47M9WVr+Rg27rxxqPd+vOfvMmcZIk\nqTC9ao6HJEmqbgYPSZJUGIOHJEkqjMFDkiQVxuAhSZIKY/CQJEmFMXhIkqTCGDwkSVJhDB6SJKkw\nBg9JPS4ivhUR13Tw3Asi4rKerklSOdwyXVK3iYjfAU+nlM5o1jYEeAEYlVL6ewdeYwNgKvnOvy/3\nVK2SyuGIh6SedjzwaEdCB0BK6Z/km3qd3KNVSSqFwUNSt4iIH5Pvfnl6RCyNiCURsSVwJDC+1bmf\njoi/RsS8iJgZEQ9GxMBmp4yvPE9SL2PwkNRdTgceB64HNgaGkm+bPRL4c+NJEbExcCvwI2Brcli5\nC4hmr/UUsFlEbFFI5ZIK06/sAiT1DimltyNiITAvpfQGQERsW3l4WrNThwKrAnenlP5WaZvc6uWm\nkYPIlsCrPVe1pKI54iGpJzVePlnQrO0Z4CHg2Yi4PSKOj4h1Wz1vfuXPNXq6QEnFMnhI6kkzK3+u\n19iQUlqaUtoH+AR5pOM/gOcq80EarV/5c0YhVUoqjMFDUndaSL6M0uj/aJrn0UJK6fGU0nnA9sAi\n4NBmD29Tea3Wl2Ak1TiDh6Tu9DLwkYjYsrIfB8BvgY81nhARO0bE2RFRFxGbA58CNgSmNHudXYFH\nUkrvFFS3pIIYPCR1pwuBJUAD8AawOXn1yphm57wN7Ab8CngeOB84I6X0QLNzjgSuK6JgScVy51JJ\nPS4ingAuSSnd1oFzP0EOMB9KKS3t8eIkFcoRD0lFOIGOL99fAzjO0CH1To54SJKkwjjiIUmSCmPw\nkCRJhTF4SJKkwhg8JElSYQwekiSpMAYPSZJUGIOHJEkqjMFDkiQVxuAhSZIK8/8BBlo/e328X7MA\nAAAASUVORK5CYII=\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x5ae16d0>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "t = 12.07 s\n" + ] + } + ], + "source": [ + "# Ex 12.8\n", + "%matplotlib inline\n", + "from matplotlib.pyplot import plot,title,xlabel,ylabel,text,axis,show\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# a-s graph\n", + "l1 = []\n", + "l2 = []\n", + "for i in range(0,51,1):\n", + " l1.append(i)\n", + " l2.append(0.16*i+2)\n", + "plot(\n", + " l1,\n", + " l2,\n", + " color='b',linewidth = 2\n", + " ) \n", + "l1 = []\n", + "l2 = []\n", + "for i in range(50,101,1):\n", + " l1.append(i)\n", + " l2.append(0)\n", + "plot(\n", + " l1,\n", + " l2,\n", + " color='b',linewidth = 2\n", + " ) \n", + "plot(\n", + " [50,50],\n", + " [0,10],\n", + " color='g',linestyle='--'\n", + " ) \n", + "plot(\n", + " [0,50],\n", + " [10,10],\n", + " color='g',linestyle='--'\n", + " ) \n", + "text(4,8,'a = 0.16*s + 2',color='r')\n", + "text(52,2,'a = 0',color='r')\n", + "axis([0,120,0,15])\n", + "title('Plot of s-t')\n", + "xlabel('t(s)')\n", + "ylabel('s(m)')\n", + "show() \n", + "print\"\\n\\n\"\n", + "# Variable Declaration\n", + "s = 100 #[meter]\n", + "t = s/50 + 10.07 #[seconds]\n", + "\n", + "# Result\n", + "print\"t = \",(t),\"s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.9 Page No 473" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "r = 30.2 m\n", + "v = 26.8 m/s\n", + "theta_v = 72.6 degrees\n", + "a = 12.8 m/s**(2)\n", + "theta_a = 90 degrees\n" + ] + } + ], + "source": [ + "# Ex 12.9\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Position\n", + "x = 16 #[meter]\n", + "y = 16**(2)/10 #[meter]\n", + "# Let r be straight line distance from A to B\n", + "r = round(math.sqrt(x**(2)+y**(2)),1) #[meter]\n", + "\n", + "# Velocity\n", + "vx = 8 #[meter per second]\n", + "vy = (2*16*8)/10 #[meter per second]\n", + "# Let v be magnitude of velocity at t = 2 s\n", + "v = round(math.sqrt(vx**(2)+vy**(2)),1) #[meter per second]\n", + "theta_v = round(math.degrees(math.atan(vy/vx)),1) #[Degrees]\n", + "\n", + "# Accceleration\n", + "ax = 0 #[meter per second square]\n", + "ay = 2*8**(2)/10+2*16*0/10 #[meter per second square]\n", + "a = round(math.sqrt(ax**(2)+ay**(2)),1) #[meter per second square]\n", + "theta_a = 90 #[Degrees]\n", + "\n", + "# Result\n", + "print\"r = \",(r),\"m\"\n", + "print\"v = \",(v),\"m/s\"\n", + "print\"theta_v = \",(theta_v),\"degrees\"\n", + "print\"a = \",(a),\"m/s**(2)\"\n", + "print\"theta_a = \",(theta_a),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.10 Page No 474" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "r_x = 0.499 m\n", + "r_y = 0.0354 m\n", + "r_z = -0.15 m\n", + "r = 0.522 m\n", + "alpha = 17.1 degrees\n", + "beta = 86.1 degrees\n", + "gamma = 106.7 degrees\n", + "v = 1.02 m/s\n", + "a = 2.0 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 12.10\n", + "import math\n", + "\n", + "# Calculation\n", + "# Position\n", + "r_x = round(0.5*math.sin(1.5),3) #[meter]\n", + "r_y = round(0.5*math.cos(1.5),4) #[meter]\n", + "r_z = round(-0.2*(0.75),4) #[meter]\n", + "r = round(math.sqrt(r_x**(2)+r_y**(2)+r_z**(2)),3) #[meter]\n", + "alpha = round(math.degrees(math.acos(r_x/r)),1) #[Degrees]\n", + "beta = round(math.degrees(math.acos(r_y/r)),1) #[Degrees]\n", + "gamma = round(math.degrees(math.acos(r_z/r)),1) #[Degrees]\n", + "\n", + "# Velocity\n", + "v = round(math.sqrt((1*math.cos(1.5))**(2)+(-1*math.sin(1.5))**(2)+(-0.2)**(2)),3) #[meter per second]\n", + "\n", + "# Accelaration\n", + "a = math.sqrt((-2*math.sin(1.5))**(2)+(-2*math.cos(1.5))**(2)) #[meter per second square]\n", + "\n", + "# Result\n", + "print\"r_x = \",(r_x),\"m\"\n", + "print\"r_y = \",(r_y),\"m\"\n", + "print\"r_z = \",(r_z),\"m\"\n", + "print\"r = \",(r),\"m\"\n", + "print\"alpha = \",(alpha),\"degrees\"\n", + "print\"beta = \",(beta),\"degrees\"\n", + "print\"gamma = \",(gamma),\"degrees\"\n", + "print\"v = \",(v),\"m/s\"\n", + "print\"a = \",(a),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 12.11 Page No 477" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tAB = 1.11 s\n", + "R = 13.32 m\n" + ] + } + ], + "source": [ + "# Ex 12.11\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "v = 12 #[meters]\n", + "# Calculation\n", + "# Vertical motion\n", + "tAB = round(math.sqrt(-6/((1/2)*(-9.81))),2) #[seconds]\n", + "\n", + "# Horizontal motion\n", + "R = 0+v*1.11 #[meter]\n", + "\n", + "# Result\n", + "print\"tAB = \",(tAB),\"s\"\n", + "print\"R = \",(R),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.12 Page No 478" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h = 1.433 m\n" + ] + } + ], + "source": [ + "# Ex 12.12\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "v0 = 10 #[meter per second]\n", + "theta = 30 #[degrees]\n", + "\n", + "# Calculation\n", + "vo_x = round(v0*math.cos(math.pi*30/180),2) #[meter per second]\n", + "vo_y = round(v0*math.sin(math.pi*30/180),2) #[meter per second]\n", + "\n", + "# Horizontal Motion\n", + "tOA = round((8-0)/vo_x,4) #[seconds]\n", + "\n", + "# Vertical Motion\n", + "h = round(0+5*tOA+(1/2)*(-9.81)*tOA**(2)+1,3) #[meter]\n", + "\n", + "# Result\n", + "print\"h = \",(h),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.13 Page No 479" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vA = 13.38 m/s\n", + "R = 17.4 m\n", + "h = 3.28 m\n" + ] + } + ], + "source": [ + "# Ex 12.13\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Calculation\n", + "# Vertical Motion\n", + "vA = round((-1-(1/2)*-9.81*1.5**(2))/(math.sin(math.pi*30/180)*1.5),2) #[meter per second]\n", + "\n", + "# Horizontal Motion\n", + "R = round(0+vA*math.cos(math.pi*30/180)*1.5,1) #[meter]\n", + "h = round(((0**(2)-(vA*math.sin(math.pi*30/180))**(2))/(2*(-9.81)))+1,2) #[meter]\n", + "\n", + "# Result\n", + "print\"vA = \",(vA),\"m/s\"\n", + "print\"R = \",(R),\"m\"\n", + "print\"h = \",(h),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.14 Page No 487" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vA = 6 m/s\n", + "a = 2.37 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 12.14\n", + "\n", + "# Calculation\n", + "# Velocity\n", + "# Velocity is always directed tangent to the path\n", + "vA = 6 #[meter per second]\n", + "\n", + "# Acceleration\n", + "rho = round(((1+((1/10)*10)**(2))**(3/2))/(1/10),2) #[meter]\n", + "at = 2 #[meter per second**(2)]\n", + "an = round((6**(2))/rho,3) #[meter per second**(2)]\n", + "a = round(math.sqrt(at**(2)+an**(2)),2) #[meter per second**(2)]\n", + "phi = round(math.degrees(math.atan(at/an)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"vA = \",(vA),\"m/s\"\n", + "print\"a = \",(a),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.15 Page No 488" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t = 7.48 s\n", + "v = 22.44 m/s\n" + ] + } + ], + "source": [ + "# Ex 12.15\n", + "\n", + "# Calculation\n", + "# Let t be time needed for acceleration to reach 3 m/s**(2)\n", + "t = round(math.sqrt((math.sqrt(3**(2)-2**(2)))/0.04),2) #[seconds]\n", + "\n", + "# Velocity\n", + "# Let v be speed at time t = 7.48 s\n", + "v = 3*t #[meter per second]\n", + "\n", + "# Result\n", + "print\"t = \",(t),\"s\"\n", + "print\"v = \",(v),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.16 Page No 489" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aB = 5.37 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 12.16\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "tB = round((6.142/0.0333)**(1/3),3) #[seconds]\n", + "aBt = 0.2*5.690 #[meter per second square]\n", + "vB = 0.1*(tB**(2)) #[meter per second]\n", + "aBn = (vB**(2))/2 #[meter per second square]\n", + "aB = round(math.sqrt(aBt**(2)+aBn**(2)),2) #[meter per second square]\n", + "\n", + "# Result\n", + "print\"aB = \",(aB),\"m/s**(2)\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.18 Page No 498" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v = 360.6 mm/s\n", + "delta = 56.3 degrees\n", + "a = 1931.3 mm/s**(2)\n", + "phi = -68.7 degrees\n" + ] + } + ], + "source": [ + "# Ex 12.18\n", + "import math\n", + "\n", + "# Calculation\n", + "vr = 200*1 #[millimeter per second]\n", + "vtheta = 100*(1)**(2)*3**(1) #[millimeter per second]\n", + "v = round(math.sqrt(vr**(2)+vtheta**(2)),1)\n", + "delta = round(math.degrees(math.atan(vtheta/vr)),1) #[Degrees]\n", + "ar = 200-100*(3**(2)) #[millimeter per second square]\n", + "atheta = 100*6+2*200*3 #[millimeter per second square]\n", + "a = round(math.sqrt(ar**(2)+atheta**(2)),1) #[millimeter per second square]\n", + "phi = round(math.degrees(math.atan(atheta/ar)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"v = \",(v),\"mm/s\"\n", + "print\"delta = \",(delta),\"degrees\"\n", + "print\"a = \",(a),\"mm/s**(2)\"\n", + "print\"phi = \",(phi),\"degrees\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 12.19 Page No 499" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v = 800.0 m/s\n", + "a = 6400.0 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 12.19\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "vr = round(400*(1/math.cos(math.pi*45/180))*math.tan(math.pi*45/180),1) #[meter per second]\n", + "vtheta = round(100*(1/math.cos(math.pi*45/180))*4,1) #[meter per second]\n", + "v = round(math.sqrt(vr**(2)+vtheta**(2)),1) #[meter per second]\n", + "ar = round((1600*((1/math.cos(math.pi*45/180))*(math.tan(math.pi*45/180)**(2))+(1/math.cos(math.pi*45/180)**(3)))) - 100*(1/math.cos(math.pi*45/180))*4**(2),1) #[meter per second square]\n", + "atheta = round(100*(1/math.cos(math.pi*45/180))*0+2*400*(1/math.cos(math.pi*45/180))*math.tan(math.pi*45/180)*4,1) #[meter per second square]\n", + "a = round(math.sqrt(ar**(2)+atheta**(2)),1) #[meter per second square]\n", + "\n", + "# Result\n", + "print\"v = \",(v),\"m/s\"\n", + "print\"a = \",(a),\"m/s**(2)\"\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 12.20 Page No 500" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta_dot = 1.0 rad/s\n", + "theta_doubledot = 9.89 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 12.20\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "a = 10 #[meter per second square]\n", + "v = 1 #[meter per second]\n", + "\n", + "# Calculation\n", + "theta_dot = math.sqrt((v**(2))-(0**(2))) #[radian per second]\n", + "theta_doubledot = round(math.sqrt((10**(2))-((-1.5)**(2))),2) #[radian per second square]\n", + "\n", + "# Result\n", + "print\"theta_dot = \",(theta_dot),\"rad/s\"\n", + "print\"theta_doubledot = \",(theta_doubledot),\"rad/s**(2)\" # Correction in the answer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.21 Page No 506" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vA = 6 m/s\n" + ] + } + ], + "source": [ + "# Ex 12.21\n", + "\n", + "# Calculation\n", + "vA = -3*-2 #[meter per second]\n", + "\n", + "# Result\n", + "print\"vA = \",(vA),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.22 Page No 507" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vA = 8 m/s\n" + ] + } + ], + "source": [ + "# Ex 12.22\n", + "\n", + "# Calculation\n", + "vA = -4*-2 #[meter per second]\n", + "\n", + "# Result\n", + "print\"vA = \",(vA),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.23 Page No 508" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vB = -0.5 m/s\n" + ] + } + ], + "source": [ + "# Ex 12.23\n", + "\n", + "# Calculation\n", + "vB = -2/4\n", + "\n", + "# Result\n", + "print\"vB = \",(vB),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.24 Page No 509" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vS = 400.0 mm/s\n", + "aS = 3.6 mm/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 12.24\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "vA = 0.5 #[meter per second]\n", + "\n", + "# Calculation\n", + "vS = round((20*vA)/math.sqrt(225+20**(2)),1) #[meter per second]\n", + "aS = (225*vA**(2))/((225+20**(2))**(3/2)) #[meter per second square]\n", + "\n", + "# Result\n", + "print\"vS = \",(vS*1000),\"mm/s\"\n", + "print\"aS = \",(aS*1000),\"mm/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.25 Page No 512" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "vTA_x = 28.2 km/hr\n", + "vTA_y = -31.8 km/hr\n", + "vTA = 42.5 km/hr\n", + "theta = 48.4 degrees\n", + "Solution 2\n", + "vTA_x = 28.2 km/hr\n", + "vTA_y = -31.8 km/hr\n" + ] + } + ], + "source": [ + "# Ex 12.25\n", + "import math\n", + "\n", + "# Calculation Solution 1 Vector Analysis\n", + "vTA_x = round(60-45*math.cos(math.pi*45/180),1) #[kilometer per hr]\n", + "vTA_y = round(-45*math.sin(math.pi*45/180),1) #[kilometer per hr]\n", + "vTA = round(math.sqrt(vTA_x**(2)+vTA_y**(2)),1) #[kilometer per hr]\n", + "theta = round(math.degrees(math.atan(abs(vTA_y)/vTA_x)),1) #[Degrees]\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1\"\n", + "print\"vTA_x = \",(vTA_x),\"km/hr\"\n", + "print\"vTA_y = \",(vTA_y),\"km/hr\"\n", + "print\"vTA = \",(vTA),\"km/hr\"\n", + "print\"theta = \",(theta),\"degrees\"\n", + "\n", + "# Calculation Solution 2 Scalar Analysis\n", + "# vT = vA + vT/A\n", + "vTA_x = round(60-45*math.cos(math.pi*45/180),1) #[kilometer per hr]\n", + "vTA_y = round(-45*math.sin(math.pi*45/180),1) #[kilometer per hr]\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2\"\n", + "print\"vTA_x = \",(vTA_x),\"km/hr\"\n", + "print\"vTA_y = \",(vTA_y),\"km/hr\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.26 Page No 513" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aBA = 912.4 km/hr**(2)\n", + "theta = 9.5 degrees\n" + ] + } + ], + "source": [ + "# Ex 12.26\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "rho = 400 #[kilometers]\n", + "\n", + "# Calculation\n", + "# Velocity\n", + "vBA = 600-700 #[kilometers per hr]\n", + "# Acceleration\n", + "aBn = 600**(2)/rho #[kilometers per hr square]\n", + "aBA_x = 900 #[kilometers per hr square]\n", + "aBA_y = -100-50 #[kilometers per hr square]\n", + "aBA = round(math.sqrt(aBA_x**(2)+aBA_y**(2)),1) #[kilometers per hr square]\n", + "theta = round(math.degrees(math.atan(abs(aBA_y)/aBA_x)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"aBA = \",(aBA),\"km/hr**(2)\"\n", + "print\"theta = \",(theta),\"degrees\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 12.27 Page No 514" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vBA = 9.69 m/s\n", + "theta = 21.7 degrees\n", + "aBA = 5.32 m/s**(2)\n", + "phi = 62.7 degrees\n" + ] + } + ], + "source": [ + "# Ex 12.27\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "vA = 18 #[meter per second]\n", + "vB = 12 #[meter per second]\n", + "\n", + "# Calculation\n", + "# Velocity\n", + "vBA_x = 18*math.cos(math.pi*60/180) #[meter per second]\n", + "vBA_y = 18*math.sin(math.pi*60/180)-12 #[meter per second]\n", + "vBA = round(math.sqrt(vBA_x**(2)+vBA_y**(2)),2) #[meter per second]\n", + "theta = round(math.degrees(math.atan(vBA_y/vBA_x)),1) #[Degrees]\n", + "\n", + "# Acceleration\n", + "aBn = vB**(2)/100 #[meter per second square]\n", + "aBA_x = round(-1.440-2*math.cos(math.pi*60/180),3) #[meter per second square]\n", + "aBA_y = round(-3-2*math.sin(math.pi*60/180),3) #[meter per second square]\n", + "aBA = round(math.sqrt(aBA_x**(2)+aBA_y**(2)),2) #[meter per second square]\n", + "phi = round(math.degrees(math.atan(aBA_y/aBA_x)),1) #[Degrees]\n", + " \n", + "# Result\n", + "print\"vBA = \",(vBA),\"m/s\"\n", + "print\"theta = \",(theta),\"degrees\"\n", + "print\"aBA = \",(aBA),\"m/s**(2)\"\n", + "print\"phi = \",(phi),\"degrees\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_13_Kinetics_of_a_Particle_Force_and_Acceleration.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_13_Kinetics_of_a_Particle_Force_and_Acceleration.ipynb new file mode 100644 index 00000000..ada4b114 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_13_Kinetics_of_a_Particle_Force_and_Acceleration.ipynb @@ -0,0 +1,504 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 13 Kinetics of a Particle Force and Acceleration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.1 Page No 535" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v = 15.6 m/s\n" + ] + } + ], + "source": [ + "# Ex 13.1\n", + "import numpy as np\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "uk = 0.3\n", + "F = 400 #[Newton]\n", + "\n", + "# Calculation\n", + "# Using ΣF_x(right) = m*a_x and ΣF_y(upward) = m*a_y\n", + "a = np.array([[uk,50],[1,0] ])\n", + "b = np.array([F*math.cos(math.pi*30/180),490.5-F*math.sin(math.pi*30/180)])\n", + "x = np.linalg.solve(a, b)\n", + "NC = round(x[0],1) #[Newton]\n", + "a = round(x[1],1) #[meters per second square]\n", + "v = 0+a*3 #[meter per second]\n", + "\n", + "# Result\n", + "print\"v = \",(v),\"m/s\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.2 Page No 536" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Part(a)\n", + "h = 127.4 m\n", + "\n", + "Part(b)\n", + "h = 113.5 m\n" + ] + } + ], + "source": [ + "# Ex 13.2\n", + "from __future__ import division\n", + "from scipy import integrate\n", + "\n", + "# Calculation Part(a)\n", + "h = round(-(50**(2))/(2*-9.81),1) #[meters]\n", + "\n", + "# Result Part(a)\n", + "print\"Part(a)\"\n", + "print\"h = \",(h),\"m\\n\"\n", + "\n", + "# Calculation Part(b)\n", + "v = lambda v: -v/(0.001*v**(2)+9.81) \n", + "h = round(integrate.quad(v, 50, 0)[0],1) #[meters]\n", + "\n", + "# Result Part(b)\n", + "print\"Part(b)\"\n", + "print\"h = \",(h),\"m\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.3 Page No 537" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v = 0.44 m/s\n", + "T = 39.4 N\n" + ] + } + ], + "source": [ + "# Ex 13.3\n", + "from scipy import integrate\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "V = lambda t: 0.221*t\n", + "v = round(integrate.quad(V, 0, 2)[0],2) #[meters per second]\n", + "# Using ΣF_x(left) = m*a_x\n", + "T = round(40*2-(900/9.81)*0.221*2,1) #[Newton]\n", + "\n", + "# Result\n", + "print\"v = \",(v),\"m/s\"\n", + "print\"T = \",(T),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.4 Page No 538" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NC = 0.901 N\n", + "a = 9.21 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 13.4\n", + "import numpy as np\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "k = 3 #[Newtons per meter]\n", + "ul = 0.75 #[meter] (ul is the unstretched length)\n", + "y = 1 #[meter]\n", + "\n", + "# Calculation\n", + "Fs = round(k*(math.sqrt(y**(2)+0.75**(2))-ul),2) #[Newton]\n", + "theta = round(math.degrees(math.atan(y/0.75)),1) #[Degrees]\n", + "# Using ΣF_x(right) = m*a_x and ΣF_y(downward) = m*a_y\n", + "a = np.array([[1,0],[0,2] ])\n", + "b = np.array([Fs*math.cos(math.pi*theta/180),19.62-Fs*math.sin(math.pi*theta/180)])\n", + "x = np.linalg.solve(a, b)\n", + "NC = round(x[0],3) #[Newton]\n", + "a = round(x[1],2) #[meters per second square]\n", + "\n", + "# Result\n", + "print\"NC = \",(NC),\"N\"\n", + "print\"a = \",(a),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.5 Page No 539" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v = -13.1 m/s\n" + ] + } + ], + "source": [ + "# Ex 13.5\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Using ΣF_y(downward) = m*a_y (Block A), ΣF_y(downward) = m*a_y (Block B) and 2*aA = -aB\n", + "a = np.array([[2,100],[1,20*-2] ])\n", + "b = np.array([981,196.2])\n", + "x = np.linalg.solve(a, b)\n", + "T = round(x[0],1) #[Newton]\n", + "aA = round(x[1],2) #[meters per second square]\n", + "aB = -2*aA #[meters per second square]\n", + "v = round(0+aB*2,1) #[meters per second]\n", + "\n", + "# Result\n", + "print\"v = \",(v),\"m/s\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.7 Page No 548" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t = 5.88 s\n" + ] + } + ], + "source": [ + "# Ex 13.7\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "uk = 0.1\n", + "\n", + "# Calculation\n", + "# Using ΣFb = 0\n", + "ND = 29.43 #[Newton]\n", + "# Using ΣFt = m*at\n", + "at = (0.1*ND)/3 #[meters per second square]\n", + "# Using ΣFn = m*an\n", + "vcr = round(math.sqrt(100/3),2) #[meters per second]\n", + "t = round((vcr-0)/at,2) #[seconds]\n", + "\n", + "# Result\n", + "print\"t = \",(t),\"s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.8 Page No 549" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NA = 1651.4 N\n", + "aA = 13.33 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 13.8\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "v = 20 #[meters per second]\n", + "\n", + "# Calculation\n", + "rho = ((1+0**(2))**(3/2))/(1/30) #[meters]\n", + "# Using ΣFn = m*an\n", + "NA = round(700+(700/9.81)*(20**(2)/rho),1) #[Newtons]\n", + "an = v**(2)/rho #[meters per second square]\n", + "aA = round(an,2) #[meters per second square]\n", + "\n", + "# Result\n", + "print\"NA = \",(NA),\"N\"\n", + "print\"aA = \",(aA),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.9 Page No 550" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thetamax = 42.1 degrees\n" + ] + } + ], + "source": [ + "# Ex 13.9\n", + "\n", + "# Calculation\n", + "thetamax = round(math.degrees((9.81+1)/((19.62*0.5/2)+9.81)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"thetamax = \",(thetamax),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 13.10 Page No 556" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F = 0.41 N\n", + "N = 0.28 N\n" + ] + } + ], + "source": [ + "# Ex 13.10\n", + "import numpy as np\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "a = np.array([[math.cos(math.pi*14.04/180),-math.sin(math.pi*14.04/180)],[math.sin(math.pi*14.04/180),math.cos(math.pi*14.04/180)] ])\n", + "b = np.array([(2/32.2)*(6-3*0.5**(2)),(2/32.2)*(3*0+2*6*0.5)])\n", + "x = np.linalg.solve(a, b)\n", + "F = round(x[0],2) #[Newton]\n", + "N = round(x[1],2) #[Newton]\n", + "\n", + "# Result\n", + "print\"F = \",(F),\"N\" #[Correction in the answer]\n", + "print\"N = \",(N),\"N\" #[Correction in the answer]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.11 Page No 557" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FP = -0.354 N\n", + "NC = 19.4 N\n" + ] + } + ], + "source": [ + "# Ex 13.11\n", + "import numpy as np\n", + "import math\n", + "\n", + "\n", + "# Variable Declaration\n", + "theta = 60 #[Degrees]\n", + "\n", + "# Calculation\n", + "a = np.array([[0,-math.sin(math.pi*theta/180)],[1,-math.cos(math.pi*theta/180)] ])\n", + "b = np.array([2*(0.192-0.462*(0.5**(2)))-19.62*math.sin(math.pi*theta/180),2*(0+2*-0.133*0.5)-19.62*math.cos(math.pi*theta/180)])\n", + "x = np.linalg.solve(a, b)\n", + "FP = round(x[0],3) #[Newton]\n", + "NC = round(x[1],1) #[Newton]\n", + "\n", + "# Result\n", + "print\"FP = \",(FP),\"N\" \n", + "print\"NC = \",(NC),\"N\" " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 13.12 Page No 558" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FC = 0.8 N\n", + "NC = -2.64 N\n" + ] + } + ], + "source": [ + "# Ex 13.12\n", + "import numpy as np\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "a = np.array([[0,math.cos(math.pi*17.7/180)],[1,-math.sin(math.pi*17.7/180)] ])\n", + "b = np.array([0.5*(0-0.1*math.pi*4**(2)),0.5*(0+2*0.4*4)])\n", + "x = np.linalg.solve(a, b)\n", + "FC = round(x[0],1) #[Newton]\n", + "NC = round(x[1],2) #[Newton]\n", + "\n", + "# Result\n", + "print\"FC = \",(FC),\"N\" \n", + "print\"NC = \",(NC),\"N\" " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_14_Kinetics_of_a_Particle_Work_and_Energy_.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_14_Kinetics_of_a_Particle_Work_and_Energy_.ipynb new file mode 100644 index 00000000..2fcc32fb --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_14_Kinetics_of_a_Particle_Work_and_Energy_.ipynb @@ -0,0 +1,428 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 14 Kinetics of a Particle : Work and Energy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.1 Page No 569" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "UT = 504.7 J\n" + ] + } + ], + "source": [ + "# Ex 14.1\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "P = 400 #[Newtons]\n", + "s = 2 #[meters]\n", + "\n", + "# Calculation\n", + "# Horizontal Force P\n", + "UP = round(P*s*math.cos(math.pi*30/180),1) #[Joules]\n", + "# Spring force Fs\n", + "Us = round(-((1/2)*30*2.5**(2)-(1/2)*30*0.5**(2)),1) #[Joules]\n", + "# Weight W\n", + "UW = round(-98.1*(2*math.sin(math.pi*30/180)),1) #[Joules]\n", + "# Total Work\n", + "UT = UP+Us+UW #[Joules]\n", + "\n", + "# Result\n", + "print\"UT = \",(UT),\"J\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.2 Page No 574" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "s = 4.0 m\n" + ] + } + ], + "source": [ + "# Ex 14.2\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "uk = 0.5\n", + "m = 20 #[kilo Newton]\n", + "\n", + "# Calculation\n", + "# Using +ΣFn = 0\n", + "NA = round(m*math.cos(math.pi*10/180),2) #[kilo Newtons]\n", + "FA = uk*NA #[kilo Newtons]\n", + "# Principle of Work and Energys\n", + "s = round((-(1/2)*(m/9.81)*(5**(2)))/(m*math.sin(math.pi*10/180)-9.85),1) #[meters]\n", + " \n", + "# Result\n", + "print\"s = \",(s),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.3 Page No 575" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v = 5.47 m/s\n", + "t = 1.79 s\n" + ] + } + ], + "source": [ + "# Ex 14.3\n", + "from __future__ import division\n", + "from scipy import integrate\n", + "\n", + "# Calculation\n", + "v = round((2.78*3+0.8*3**(3))**(1/2),2) #[meters per second]\n", + "x = lambda s : 1/((2.78*s+0.8*s**(3))**(1/2))\n", + "t = round(integrate.quad(x,0,3)[0],2) #[seconds]\n", + " \n", + "# Result\n", + "print\"v = \",(v),\"m/s\"\n", + "print\"t = \",(t),\"s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.4 Page No 576" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h = 0.963 m\n" + ] + } + ], + "source": [ + "# Ex 14.4\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Using Principle of Work and Energy\n", + "h = round(((-(1/2)*200*(0.6**(2))+(1/2)*200*(0.7**(2)))/(19.62))+0.3,3) #[meters]\n", + "\n", + "# Result\n", + "print\"h = \",(h),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.5 Page No 577" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thetamax = 42.7 degrees\n" + ] + } + ], + "source": [ + "# Ex 14.5\n", + "import math\n", + "\n", + "# Calculation\n", + "thetamax = round(math.degrees(math.acos((9.81+1)/(4.905+9.81))),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"thetamax = \",(thetamax),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.6 Page No 578" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta_sB = 0.883 m\n" + ] + } + ], + "source": [ + "# EX 14.6\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "vA = -4*2 #[meters per second]\n", + "# Substituting delta_sA = -4*delta_sB\n", + "delta_sB = round(((1/2)*10*(vA**(2))+(1/2)*100*(2**(2)))/(-4*98.1+981),3) #[meters]\n", + "\n", + "# Result\n", + "print\"delta_sB = \",(delta_sB),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.8 Page No 586" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P = 162.0 kW\n" + ] + } + ], + "source": [ + "# Ex 14.8\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "uk = 0.35\n", + "\n", + "# Calculation\n", + "# Using +ΣFy(upward) = 0\n", + "NC = 19.62 #[kilo Newtons]\n", + "FC = uk*NC #[kilo Newtons]\n", + "v = round(math.sqrt(((1/2)*2000*(25**(2))-6.867*(10**(3))*10)/((1/2)*2000)),2) #[meters per second]\n", + "P = round(FC*v,1) #[kilo Watts]\n", + "\n", + "# Result\n", + "print\"P = \",(P),\"kW\" # Correction in the answer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.9 Page No 595" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T = 148.7 kN\n" + ] + } + ], + "source": [ + "# Ex 14.9\n", + "import math\n", + "\n", + "# Calculation\n", + "# Using Principle of Conservation of Energy\n", + "vB = round(math.sqrt((8000*9.81*20*math.cos(math.pi*15/180)-8000*9.81*20*math.cos(math.pi*60/180))/((1/2)*8000)),1) #[meters per second]\n", + "# Using ΣFn = m*an\n", + "T = 8000*9.81*math.cos(math.pi*15/180)+8000*(13.5**(2))/20 #[Newtons]\n", + "\n", + "# Result\n", + "print\"T = \",round((T/1000),1),\"kN\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.10 Page No 596" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sA = 0.331 m\n" + ] + } + ], + "source": [ + "# Ex 14.10\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "coeff = [13500, -2481, -660.75]\n", + "# Taking positive root\n", + "sA = round(np.roots(coeff)[0],3) #[meters]\n", + "\n", + "# Result\n", + "print\"sA = \",(sA),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 14.11 Page No 597" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Part(a)\n", + "vC = 4.39 m/s\n", + "\n", + "Part(b)\n", + "vC = 4.82 m/s\n" + ] + } + ], + "source": [ + "# Ex 14.11\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Part(a) Potential Energy\n", + "vC = round(math.sqrt((-(1/2)*3*(0.5**(2))+2*9.81*1)/((1/2)*2)),2) #[meters per second]\n", + "\n", + "# Result Part(a)\n", + "print\"Part(a)\"\n", + "print\"vC = \",(vC),\"m/s\\n\"\n", + "\n", + "# Part(b) Conservation of Energy\n", + "vC = round(math.sqrt(((1/2)*2*(2**(2))-(1/2)*3*(0.5**(2))+2*9.81*1)/((1/2)*2)),2) #[meters per second]\n", + "\n", + "# Result Part(b)\n", + "print\"Part(b)\"\n", + "print\"vC = \",(vC),\"m/s\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_15_Kinetics_of_a_Particle_Impulse_and_Momentum.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_15_Kinetics_of_a_Particle_Impulse_and_Momentum.ipynb new file mode 100644 index 00000000..1157bdc9 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_15_Kinetics_of_a_Particle_Impulse_and_Momentum.ipynb @@ -0,0 +1,570 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 15 Kinetics of a Particle : Impulse and Momentum" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.1 Page No 607" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v2 = 14.1 m/s\n", + "NC = 839.6 N\n" + ] + } + ], + "source": [ + "# Ex 15.1\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "ws = 100 #[kilogram]\n", + "F = 200 #[Newton]\n", + "theta = 45 #[degrees]\n", + "\n", + "# Calculation\n", + "v2 = round(F*10*math.cos(math.pi*theta/180)/100,1) #[meters per second]\n", + "NC = round((9.81*ws*10-F*10*math.sin(math.pi*theta/180))/10,1) #[Newtons]\n", + "\n", + "# Result\n", + "print\"v2 = \",(v2),\"m/s\"\n", + "print\"NC = \",(NC),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.2 Page No 608" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v2 = 7.67 m/s\n", + "NC = 433.0 N\n" + ] + } + ], + "source": [ + "# Ex 15.2\n", + "import math\n", + "\n", + "# Calculation\n", + "# Using +ΣFy = 0\n", + "NC = round(500*math.cos(math.pi*30/180),1) #[Newtons]\n", + "v2 = round((50.97+100-0.6*NC+500)/50.97,2) #[meters per second]\n", + "\n", + "# Result\n", + "print\"v2 = \",(v2),\"m/s\"\n", + "print\"NC = \",(NC),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.3 Page No 609" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vB2 = 35.8 m/s\n", + "TB = 19.2 N\n" + ] + } + ], + "source": [ + "# Ex 15.3\n", + "import numpy as np\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "a = np.array([[-(1/2)*3,2*6], [5,6]])\n", + "b = np.array([3*9.81*6,5*9.81*6])\n", + "x = np.linalg.solve(a, b)\n", + "vB2 = round(x[0],1) #[meters per second]\n", + "TB = round(x[1],1) #[Newtons]\n", + "\n", + "# Result\n", + "print\"vB2 = \",(vB2),\"m/s\"\n", + "print\"TB = \",(TB),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.4 Page No 616" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v2 = 0.5 m/s\n", + "Favg = 18.75 kN\n" + ] + } + ], + "source": [ + "# Ex 15.4\n", + "\n", + "# Calculation\n", + "# Part(a)\n", + "v2 = (15000*1.5-12000*0.75)/27000 #[meters per second]\n", + "# Part(b)\n", + "Favg = (15000*1.5-15000*0.5)/0.8 #[Newtons]\n", + "\n", + "# Result\n", + "print\"v2 = \",(v2),\"m/s\"\n", + "print\"Favg = \",(Favg/1000),\"kN\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.5 Page No 617" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vC2 = 4.0 m/s\n", + "Favg = 66.67 kN\n" + ] + } + ], + "source": [ + "# Ex 15.5\n", + "\n", + "# Calculation\n", + "# Part(a)\n", + "vC2 = 4*500/500 #[meters per second]\n", + "# Part(b)\n", + "Favg = 4*500/0.03 #[Newtons]\n", + "\n", + "# Result\n", + "print\"vC2 = \",(vC2),\"m/s\"\n", + "print\"Favg = \",round((Favg/1000),2),\"kN\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.6 Page No 618" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vT2 = 2.63 m/s\n" + ] + } + ], + "source": [ + "# Ex 15.6\n", + "\n", + "# Calculation\n", + "vT2 = round((350*10**(3)*3)/(350*10**(3)+50*10**(3)),2) #[meters per second]\n", + "\n", + "# Result\n", + "print\"vT2 = \",(vT2),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.7 Page No 619" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Impulse = 682.9 N.s\n" + ] + } + ], + "source": [ + "# Ex 15.7\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "mH = 300 #[kilogram]\n", + "mP = 800 #[kilogram]\n", + "\n", + "# Calculation\n", + "# Using conservation of energy\n", + "vH1 = round(math.sqrt((mH*9.81*0.5)/((1/2)*mH)),2) #[meters per second]\n", + "# Using conservation of momentum\n", + "v2 = (mH*3.13)/(mH+mP) #[meters per second]\n", + "# Using Principle of Impulse and Momentum\n", + "Impulse = round(300*vH1-300*v2,1) #[Newtons second]\n", + "\n", + "# Result\n", + "print\"Impulse = \",(Impulse),\"N.s\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.9 Page No 627" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Energy_loss = -33.15 J\n" + ] + } + ], + "source": [ + "# Ex 15.9\n", + "import numpy as np\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Using conservation of energy\n", + "vA1 = round(math.sqrt((6*9.81*1)/((1/2)*6)),2)\n", + "# Using Conservation of Momentum and formula for coefficient of restitution\n", + "a = np.array([[1,3], [1,-1]])\n", + "b = np.array([4.43,-2.215])\n", + "x = np.linalg.solve(a, b)\n", + "vA2 = round(x[0],3) #[meters per second]\n", + "vB2 = round(x[1],2) #[meters per second]\n", + "Energy_loss = round((1/2)*18*vB2**(2)+(1/2)*6*vA2**(2)-(1/2)*6*vA1**(2),2) #[Joules]\n", + "\n", + "# Result\n", + "print\"Energy_loss = \",(Energy_loss),\"J\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.10 Page No 628" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "s3 = 237.0 mm\n" + ] + } + ], + "source": [ + "# Ex 15.10\n", + "from __future__ import division\n", + "import numpy as np\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "wB = 1.5 #[kilogram]\n", + "k = 800 #[Newton meter]\n", + "\n", + "# Calculation\n", + "# Using Principle of conservation of energy\n", + "vB1 = round(math.sqrt((-wB*9.81*1.25+(1/2)*k*0.25**(2))/((1/2)*1.5)),2) #[meters per second]\n", + "# Using Principle of coefficient of restitution\n", + "vB2 = 0.8*(0-2.97)+0 #[meters per second]\n", + "# Using Principle of conservation of energy\n", + "coeff = [400,-14.72,-18.94]\n", + "# Taking positive root\n", + "s3 = round(np.roots(coeff)[0],3) #[meters]\n", + "\n", + "# Result\n", + "print\"s3 = \",(s3*1000),\"mm\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.11 Page No 629" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vAx2 = -1.26 m/s\n", + "vBx2 = 1.22 m/s\n", + "vAy2 = 1.5 m/s\n", + "vBy2 = -0.71 m/s\n" + ] + } + ], + "source": [ + "# Ex 15.11\n", + "import numpy as np\n", + "import math\n", + "\n", + "# Calculation\n", + "vAx1 = round(3*math.cos(math.pi*30/180),2)\n", + "vAy1 = round(3*math.sin(math.pi*30/180),2)\n", + "vBx1 = round(-1*math.cos(math.pi*45/180),2)\n", + "vBy1 = round(-1*math.sin(math.pi*45/180),2)\n", + "# Using Conservation of \"x\" Momentum and Coefficient of restitution\n", + "a = np.array([[1,2], [-1,1]])\n", + "b = np.array([1.18,2.48])\n", + "x = np.linalg.solve(a, b)\n", + "vAx2 = round(x[0],3) #[meters per second]\n", + "vBx2 = round(x[1],2) #[meters per second]\n", + "# Using Conservation of \"x\" Momentum\n", + "vAy2 = vAy1\n", + "vBy2 = vBy1\n", + "\n", + "# Result\n", + "print\"vAx2 = \",(vAx2),\"m/s\"\n", + "print\"vBx2 = \",(vBx2),\"m/s\"\n", + "print\"vAy2 = \",(vAy2),\"m/s\"\n", + "print\"vBy2 = \",(vBy2),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.13 Page No 640" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vA2 = 20.0 m/s\n" + ] + } + ], + "source": [ + "# Ex 15.13\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "P = 10 #[Newton]\n", + "wB = 5 #[kilogram]\n", + "\n", + "# Calculation\n", + "vA2 = ((3/2)*(4**(2)-0**(2))+0.4*P*4)/(wB*0.4) #[meters per second]\n", + "\n", + "# Result\n", + "print\"vA2 = \",(vA2),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.14 Page No 641" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "UF = 2.31 J\n" + ] + } + ], + "source": [ + "# Ex 15.14\n", + "\n", + "# Variable Declaration\n", + "v1 = 1 #[meters per second]\n", + "r1 = 0.5 #[meters]\n", + "r2 = 0.2 #[meters]\n", + "vC = 2 #[meters per second]\n", + "\n", + "# Calculation\n", + "# Part(a)\n", + "# Using principle of Conservation of Angular Momentum\n", + "v2dash = (r1*0.5*v1)/(r2*0.5) #[meters per second]\n", + "v2 = round(math.sqrt(2.5**(2)+2**(2)),2) #[meters per second]\n", + "# Part(b)\n", + "UF = (1/2)*0.5*v2**(2)-(1/2)*0.5*v1**(2) #[Joules]\n", + "\n", + "# Result\n", + "print\"UF = \",(UF),\"J\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 15.15 Page No 642" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vD2doubledash = 0.838 m/s\n" + ] + } + ], + "source": [ + "# Ex 15.15\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "vD1 = 1.5 #[meters per second]\n", + "kc = 20 #[Newtons per meter]\n", + "\n", + "# Calculation\n", + "# Using principle of Conservation of Angular Momentum\n", + "vD2dash = (0.5*2*1.5)/(0.7*2) #[meters per second]\n", + "# Using Conservation of Energy\n", + "vD2 = round(math.sqrt(((1/2)*2*vD1**(2)-(1/2)*kc*0.2**(2))/((1/2)*2)),2) #[meters per second]\n", + "vD2doubledash = round(math.sqrt(vD2**(2)-vD2dash**(2)),3) #[meters per second]\n", + "\n", + "# Result\n", + "print\"vD2doubledash = \",(vD2doubledash),\"m/s\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_16_Planar_Kinematics_of_a_Rigid_Body.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_16_Planar_Kinematics_of_a_Rigid_Body.ipynb new file mode 100644 index 00000000..677b13e4 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_16_Planar_Kinematics_of_a_Rigid_Body.ipynb @@ -0,0 +1,718 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 16 Planar Kinematics of a Rigid Body" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.2 Page No 659" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vP = 1.23 m/s\n", + "alphaP = 3.78 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 16.2\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "alphaA = 2 #[radians per second square]\n", + "\n", + "# Calculation\n", + "thetaB = round(1*(2*math.pi)/1,3) #[radians]\n", + "thetaA = round(thetaB*0.4/0.15,2) #[radians]\n", + "wA = round(math.sqrt(0+2*2*(thetaA-0)),3) #[radians per second]\n", + "wB = wA*0.15/0.4 #[radians per second]\n", + "alphaB = alphaA*0.15/0.4 #[radians per second square]\n", + "vP = round(wB*0.4,2) #[meters per second]\n", + "alphaPt = alphaB*0.4 #[radians per second square]\n", + "alphaPn = wB**(2)*0.4 #[radians per second square]\n", + "alphaP = round(math.sqrt(alphaPt**(2)+alphaPn**(2)),2) #[radians per second square]\n", + "\n", + "# Result\n", + "print\"vP = \",(vP),\"m/s\"\n", + "print\"alphaP = \",(alphaP),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 16.5 Page No 666" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w = 0.62 rad/s\n", + "alpha = -0.416 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 16.5\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "theta = 30 #[degrees]\n", + "vC = 0.5 #[meter per second]\n", + "\n", + "# Calculation\n", + "s = round(math.sqrt(5-4*math.cos(math.pi*theta/180)),3) #[meters]\n", + "w = round((s*0.5)/(2*math.sin(math.pi*theta/180)),3) #[radians per second]\n", + "alpha = round((0.5**(2)-2*math.cos(math.pi*theta/180)*w**(2))/(2*math.sin(math.pi*theta/180)),3) #[Degrees]\n", + "\n", + "# Result\n", + "print\"w = \",(w),\"rad/s\"\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.6 Page No 673" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w = 14.1 rad/s\n", + "vB = 2.0 m/s\n" + ] + } + ], + "source": [ + "# Ex 16.6\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "vA = 2 #[meters per second]\n", + "theta = 45 #[Degrees]\n", + "\n", + "# Calculation\n", + "# Equating j component\n", + "w = round(vA/(0.2*math.sin(math.pi*theta/180)),1) #[radians per second]\n", + "# Equating i component\n", + "vB = round(0.2*w*math.sin(math.pi*theta/180),1) #[meters per second]\n", + "\n", + "# Result\n", + "print\"w = \",(w),\"rad/s\"\n", + "print\"vB = \",(vB),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.7 Page No 674" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1 Vector Analysis\n", + "vA = 5.0 m/s\n", + "theta = 36.9 degrees\n", + "\n", + "Solution 2 Scalar Analysis\n", + "vA = 5.0 m/s\n", + "theta = 36.9 degrees\n" + ] + } + ], + "source": [ + "# Ex 16.7\n", + "import math\n", + "\n", + "# Calculation\n", + "# Solution 1 Vector Analysis\n", + "vA_x = 1+3.0 #[meters per second]\n", + "vA_y = 3 #[meters per second]\n", + "vA = round(math.sqrt(vA_x**(2)+vA_y**(2)),1) #[meters per second]\n", + "theta = round(math.degrees(math.atan(vA_y/vA_x)),1) #[Degrees]\n", + "\n", + "# Result 1 Vector Analysis\n", + "print\"Solution 1 Vector Analysis\"\n", + "print\"vA = \",(vA),\"m/s\"\n", + "print\"theta = \",(theta),\"degrees\\n\"\n", + "\n", + "# Solution 2 Scalar Analysis\n", + "vA_x = 1+4.24*math.cos(math.pi*45/180) #[meters per second]\n", + "vA_y = 0+4.24*math.sin(math.pi*45/180) #[meters per second]\n", + "vA = round(math.sqrt(vA_x**(2)+vA_y**(2)),1) #[meters per second]\n", + "theta = round(math.degrees(math.atan(vA_y/vA_x)),1) #[Degrees]\n", + "\n", + "# Result 2 Scalar Analysis\n", + "print\"Solution 2 Scalar Analysis\"\n", + "print\"vA = \",(vA),\"m/s\"\n", + "print\"theta = \",(theta),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.8 Page No 675" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vB = 2.0 m/s\n", + "wAB = 10.0 rad/s\n" + ] + } + ], + "source": [ + "# Ex 16.8\n", + "\n", + "# Calculation\n", + "# Link CB\n", + "wCB = 2/0.2 #[radians per second]\n", + "vB = 0.2*wCB #[meters per second]\n", + "# Link AB\n", + "wAB = 2/0.2 #[radians per second]\n", + "\n", + "# Result\n", + "print\"vB = \",(vB),\"m/s\"\n", + "print\"wAB = \",(wAB),\"rad/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.9 Page No 676" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wBC = 15.0 rad/s\n", + "wD = 52.0 rad/s\n" + ] + } + ], + "source": [ + "# Ex 16.9\n", + "\n", + "# Calculation\n", + "# Link BC\n", + "vC = 5.20 #[meters per second]\n", + "wBC = 3.0/0.2 #[radians per second]\n", + "# Wheel\n", + "wD = 5.20/0.1 #[radians per second]\n", + "\n", + "# Result\n", + "print\"wBC = \",(wBC),\"rad/s\"\n", + "print\"wD = \",(wD),\"rad/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.11 Page No 684" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wBD = 5.3 rad/s\n", + "wAB = 5.3 rad/s\n" + ] + } + ], + "source": [ + "# Ex 16.10\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "vD = 3 #[meters per second]\n", + "\n", + "# Calculation\n", + "rBIC = round(0.4*math.tan(math.pi*45/180),1) #[meters]\n", + "rDIC = round(0.4/math.cos(math.pi*45/180),3) #[meters]\n", + "wBD = round(vD/rDIC,2) #[radians per second]\n", + "vB = wBD*rBIC #[meters per second]\n", + "wAB = vB/0.4 #[radians per second]\n", + "\n", + "# Result\n", + "print\"wBD = \",(wBD),\"rad/s\"\n", + "print\"wAB = \",(wAB),\"rad/s\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.12 Page No 685" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w = 2.6 rad/s\n", + "vC = 0.075 m/s\n" + ] + } + ], + "source": [ + "# Ex 16.12\n", + "\n", + "# Calculation\n", + "x = 0.1/0.65 #[meters]\n", + "w = 0.4/x #[radians per second]\n", + "vC = w*(x-0.125) #[meters per second]\n", + "\n", + "# Result\n", + "print\"w = \",(w),\"rad/s\"\n", + "print\"vC = \",(vC),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.13 Page No 691" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "alpha = 0.344 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 16.13\n", + "import numpy as np\n", + "import math\n", + "\n", + "# Calculation\n", + "a = np.array([[math.cos(math.pi*45/180),0],[math.sin(math.pi*45/180),-10]])\n", + "b = np.array([3*math.cos(math.pi*45/180)-0.283**(2)*10,-3*math.sin(math.pi*45/180)])\n", + "x = np.linalg.solve(a, b)\n", + "aB = x[0] #[meters per second square]\n", + "alpha = round(x[1],3) #[radians per second square]\n", + " \n", + "# Result\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\" " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.15 Page No 693" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aB_x = -20.0 m/s**(2)\n", + "aB_y = 2.0 m/s**(2)\n", + "aA_x = -4.0 m/s**(2)\n", + "aA_y = -18.0 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 16.15\n", + "\n", + "# Calculation\n", + "# For point B\n", + "aB_x = -2-6**(2)*0.5 #[meters per second square]\n", + "aB_y = 4*0.5 #[meters per second square]\n", + "# For point A\n", + "aA_x = -2-4*0.5 #[meters per second square]\n", + "aA_y = -6**(2)*0.5 #[meters per second square]\n", + "\n", + "# Result\n", + "print\"aB_x = \",(aB_x),\"m/s**(2)\"\n", + "print\"aB_y = \",(aB_y),\"m/s**(2)\"\n", + "print\"aA_x = \",(aA_x),\"m/s**(2)\"\n", + "print\"aA_y = \",(aA_y),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.16 Page No 694" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aB = 9.25 m/s**(2)\n", + "theta = 71.1 degrees\n" + ] + } + ], + "source": [ + "# Ex 16.16\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "w = 3 #[radians per second]\n", + "alpha = 4 #[radians per second square]\n", + "\n", + "# Calculation\n", + "aB_x = alpha*0.75 #[meters per second square]\n", + "aB_y = -2-w**(2)*0.75 #[meters per second square]\n", + "aB = round(math.sqrt(aB_x**(2)+aB_y**(2)),2) #[meters per second square]\n", + "theta = round(math.degrees(math.atan(-aB_y/aB_x)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"aB = \",(aB),\"m/s**(2)\"\n", + "print\"theta = \",(theta),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.17 Page No 695" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "alphaCB = 5.0 rad/s**(2)\n", + "alphaAB = -95.0 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 16.17\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "a = np.array([[0.2,-0.2],[0,0.2]])\n", + "b = np.array([-20,1])\n", + "x = np.linalg.solve(a, b)\n", + "alphaAB = round(x[0],1) #[meters per second square]\n", + "alphaCB = round(x[1],1) #[radians per second square]\n", + " \n", + "# Result\n", + "print\"alphaCB = \",(alphaCB),\"rad/s**(2)\" \n", + "print\"alphaAB = \",(alphaAB),\"rad/s**(2)\" " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.18 Page No 696" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "alphaBC = 27.7 rad/s**(2)\n", + "aC = -13.6 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 16.18\n", + "import numpy as np\n", + "import math\n", + "\n", + "# Calculation\n", + "rB_x = -0.25*math.sin(math.pi*45/180) #[meters]\n", + "rB_y = 0.25*math.cos(math.pi*45/180) #[meters]\n", + "rCB_x = 0.75*math.sin(math.pi*13.6/180) #[meters]\n", + "rCB_y = 0.75*math.cos(math.pi*13.6/180) #[meters]\n", + "aB_x = np.cross([0,0,-20],[-0.177,0.177,0])[0]-10**(2)*-0.177 #[meters per second square]\n", + "aB_y = np.cross([0,0,-20],[-0.177,0.177,0])[1]-10**(2)*0.177 #[meters per second square]\n", + "alphaBC = round(20.17/0.729,1) #[radians per second square]\n", + "aC = round(0.176*alphaBC-18.45,1) #[meters per second square]\n", + "\n", + "# Result\n", + "print\"alphaBC = \",(alphaBC),\"rad/s**(2)\"\n", + "print\"aC = \",(aC),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.19 Page No 705" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aCor_x = 0 m/s**(2)\n", + "aCor_y = -12 m/s**(2)\n", + "vC_x = 2 m/s\n", + "vC_y = -0.6 m/s\n", + "aC_x = 1.2 m/s\n", + "aC_y = -12.4 m/s\n" + ] + } + ], + "source": [ + "# Ex 16.19\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "aCor_x = np.cross([0,0,2*-3],[2,0,0])[0] #[meters per second square]\n", + "aCor_y = np.cross([0,0,2*-3],[2,0,0])[1] #[meters per second square]\n", + "vC_x = 2 #[meters per second]\n", + "vC_y = -0.6 #[meters per second]\n", + "aC_x = 3-1.80 #[meters per second square]\n", + "aC_y = -0.4-12 #[meters per second square]\n", + "\n", + "# Result\n", + "print\"aCor_x = \",(aCor_x),\"m/s**(2)\"\n", + "print\"aCor_y = \",(aCor_y),\"m/s**(2)\"\n", + "print\"vC_x = \",(vC_x),\"m/s\"\n", + "print\"vC_y = \",(vC_y),\"m/s\"\n", + "print\"aC_x = \",(aC_x),\"m/s\"\n", + "print\"aC_y = \",(aC_y),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 16.20 Page No 706" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wDE = 3 rad/s\n", + "alphaDE = -5.0 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 16.20\n", + "\n", + "# Calculation\n", + "vCDxyz = 1.2 #[meters per second]\n", + "wDE = 3 #[radians per second]\n", + "aCDxyz = 3.6-2 #[meters per second square]\n", + "alphaDE = (7.2-5.2)/-0.4 #[radians per second square]\n", + "\n", + "# Result\n", + "print\"wDE = \",(wDE),\"rad/s\"\n", + "print\"alphaDE = \",(alphaDE),\"rad/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 16.21 Page No 707" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vABxyz_x = 0 km/h\n", + "vABxyz_y = 94.0 km/h\n", + "aABxyz_x = -609 km/h**(2)\n", + "aABxyz_y = 152 km/h**(2)\n" + ] + } + ], + "source": [ + "# Ex 16.21\n", + "\n", + "# Calculation\n", + "vABxyz_x = 0 #[kilometer per hour]\n", + "vABxyz_y = 700-600-(-1.5*-4) #[kilometer per hour]\n", + "aABxyz_x = -900+9+282 #[kilometer per hour square]\n", + "aABxyz_y = 50+100+2 #[kilometer per hour square]\n", + "\n", + "# Result\n", + "print\"vABxyz_x = \",(vABxyz_x),\"km/h\"\n", + "print\"vABxyz_y = \",(vABxyz_y),\"km/h\"\n", + "print\"aABxyz_x = \",(aABxyz_x),\"km/h**(2)\"\n", + "print\"aABxyz_y = \",(aABxyz_y),\"km/h**(2)\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_17_Planar_Kinetics_of_a_Rigid_Body_Force_and_Acceleration.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_17_Planar_Kinetics_of_a_Rigid_Body_Force_and_Acceleration.ipynb new file mode 100644 index 00000000..ea63db73 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_17_Planar_Kinetics_of_a_Rigid_Body_Force_and_Acceleration.ipynb @@ -0,0 +1,744 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 17 Planar Kinetics of a Rigid Body Force and Acceleration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.2 Page No 719" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iy = 0.349 Mg.m**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.2\n", + "from scipy import integrate\n", + "import math\n", + "\n", + "# Calculation\n", + "y = lambda y: ((math.pi*2)/2)*y**(8)\n", + "Iy = round(integrate.quad(y, 0, 1)[0],3) #[milligram meter square]\n", + "\n", + "# Result\n", + "print\"Iy = \",(Iy),\"Mg.m**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.3 Page No 722" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IO = 1.2 kg m**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.3\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "d = 8000 #[kilogram per meter cube]\n", + "t = 0.01 #[meter]\n", + "\n", + "# Calculation\n", + "md = round(d*math.pi*0.25**(2)*t,2)\n", + "# Disk\n", + "IdO = (1/2)*md*0.25**(2)+md*0.25**(2) #[kilogram meter square]\n", + "\n", + "# Hole\n", + "IhO = (1/2)*3.93*0.125**(2)+3.93*0.25**(2) #[kilogram meter square]\n", + "\n", + "# Let IO be moment of inertia about point O\n", + "IO = round(IdO-IhO,2) #[kilogram meter square]\n", + "\n", + "# Result\n", + "print\"IO = \",(IO),\"kg m**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.4 Page No 723" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IO = 14.167 kg.m**(2)\n", + "IG = 2.917 kg.m**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.4\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "m = 10 #[kilogram]\n", + "\n", + "# Calculation\n", + "# Part(a)\n", + "IOAO = (1/3)*m*1**(2) #[kilogram meter square]\n", + "IBCO = (1/12)*m*1**(2)+m*1**(2) #[kilogram meter square]\n", + "# Let IO be moment of inertia about O\n", + "IO = round(IOAO+IBCO,3) #[kilogram meter square]\n", + "\n", + "# Part(b)\n", + "ybar = (0.5*10+1*10)/(10+10) #[meter]\n", + "IG = round(IO-2*m*ybar**(2),3) #[kilogram meter square]\n", + "\n", + "# Result\n", + "print\"IO = \",(IO),\"kg.m**(2)\"\n", + "print\"IG = \",(IG),\"kg.m**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.5 Page No 733" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NA = 6.88 kN\n", + "NB = 12.74 kN\n", + "aG = 1.59 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.5\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Using +ΣF_x = m(aG)_x, +ΣF_y = m(aG)_y and +ΣMG(counter clockwise)=0 \n", + "a = np.array([[0,-0.25,2000],[1,1,0],[-1.25,-0.25*0.3+0.75,0]])\n", + "b = np.array([0,2000*9.81,0])\n", + "x = np.linalg.solve(a, b)\n", + "NA = round(x[0]/1000,2) #[kilo Newton]\n", + "NB = round(x[1]/1000,2) #[kilo Newton]\n", + "aG = round(x[2],2) #[meters per second square]\n", + "\n", + "# Result\n", + "print\"NA = \",(NA),\"kN\"\n", + "print\"NB = \",(NB),\"kN\"\n", + "print\"aG = \",(aG),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.6 Page No 734" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "usmin = 0.912\n" + ] + } + ], + "source": [ + "# Ex 17.6\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "mm = 125 #[kilogram]\n", + "mr = 75 #[kilogram]\n", + "\n", + "# Calculation\n", + "# Using +ΣF_x = m(aG)_x, +ΣF_y = m(aG)_y and +ΣMG(counter clockwise)=0 \n", + "a = np.array([[1,0,-(mm+mr)],[0,1,0],[0,0,mr*0.9+mm*0.6]])\n", + "b = np.array([0,735.75+1226.25,-735.75*0.4-1226.25*0.8])\n", + "x = np.linalg.solve(a, b)\n", + "FB = round(x[0],1) #[kilo Newton]\n", + "NB = round(x[1],1) #[kilo Newton]\n", + "aG = round(x[2],2) #[meters per second square]\n", + "# Let usmin be minimum coefficient of static friction\n", + "usmin = round(-FB/NB,3)\n", + "\n", + "# Result\n", + "print\"usmin = \",(usmin)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.7 Page No 736" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NC = 490.5 N\n", + "x = 0.467 m\n", + "aG = 10.0 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.7\n", + "\n", + "# Variable Declaration\n", + "P = 600 #[Newton]\n", + "uk = 0.2\n", + "\n", + "# Calculation\n", + "# Using +ΣF_y = m(aG)_y\n", + "NC = 490.5 #[Newton]\n", + "\n", + "# Using +ΣF_x = m(aG)_x\n", + "aG = round((600-uk*NC)/50,1) #[meters per second square]\n", + "\n", + "# Using +ΣMG(counter clockwise)=0 \n", + "x = round((uk*NC*0.5+600*0.3)/NC,3) #[meter]\n", + "\n", + "# Result\n", + "print\"NC = \",(NC),\"N\"\n", + "print\"x = \",(x),\"m\"\n", + "print\"aG = \",(aG),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 17.8 Page No 736" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TB = 1.32 kN\n", + "TD = 1.32 kN\n", + "aG = 4.9 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.8\n", + "import numpy as np\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "theta = 30 #[Degrees]\n", + "\n", + "# Calculation\n", + "# Using +ΣFn = 0, +ΣFt = 0 and +ΣMG(counterclockwise) = 0\n", + "a = np.array([[1,1,0],[0,0,100],[-math.cos(math.pi*theta/180)*0.4,0.4*math.cos(math.pi*theta/180),0]])\n", + "b = np.array([981*math.cos(math.pi*theta/180)+100*18,981*math.sin(math.pi*theta/180),0])\n", + "x = np.linalg.solve(a, b)\n", + "TB = round(x[0]/1000,2) #[kilo Newton]\n", + "TD = round(x[1]/1000,2) #[kilo Newton]\n", + "aG = round(x[2],2) #[meters per second square]\n", + "\n", + "# Result\n", + "print\"TB = \",(TB),\"kN\"\n", + "print\"TD = \",(TD),\"kN\"\n", + "print\"aG = \",(aG),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.9 Page No 742" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ox = 0 N\n", + "Oy = 304.3 N\n", + "theta = 2.72 rev\n" + ] + } + ], + "source": [ + "# Ex 17.9\n", + "\n", + "# Calculation\n", + "# Using +ΣFx(right) = m(aG)x\n", + "Ox = 0 #[Newton]\n", + "\n", + "# Using +ΣFy(upward) = m(aG)y\n", + "Oy = 294.3+10 #[Newton]\n", + "\n", + "# Using +ΣMO(counterclockwise) = IO*alpha\n", + "alpha = (-10*0.2-5)/-0.6\n", + "theta = (-20**(2))/(2*-11.7)\n", + "theta = round(theta*(1/(2*math.pi)),2)\n", + "\n", + "# Result\n", + "print\"Ox = \",(Ox),\"N\"\n", + "print\"Oy = \",(Oy),\"N\"\n", + "print\"theta = \",(theta),\"rev\" " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.10 Page No 743" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "On = 750.0 N\n", + "Ot = 19.05 N\n", + "alpha = 5.91 rad/s**(2)\n", + "\n", + "Solution 2\n", + "alpha = 5.91 rad/s**(2)\n", + "\n", + "Solution 3\n", + "alpha = 5.91 rad/s**(2)\n", + "\n" + ] + } + ], + "source": [ + "# Ex 17.10\n", + "import numpy as np\n", + "from __future__ import division\n", + "\n", + "# Calculation Solution 1\n", + "# Using +ΣFn(left) = mw**(2)rG, +ΣFt(downwards) = malpharG and +ΣMG(clockwise) = IGalpha\n", + "a = np.array([[1,0,0],[0,1,20*1.5],[0,1.5,-(1/12)*20*3**(2)]])\n", + "b = np.array([20*5**(2)*1.5,20*9.81,-60])\n", + "x = np.linalg.solve(a, b)\n", + "On = round(x[0],2) #[Newton]\n", + "Ot = round(x[1],2) #[Newton]\n", + "alpha = round(x[2],2) #[radians per second square]\n", + "\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1\"\n", + "print\"On = \",(On),\"N\"\n", + "print\"Ot = \",(Ot),\"N\"\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\\n\"\n", + "\n", + "# Calculation Solution 2\n", + "# Using +ΣMO(clockwise) = Σ(Mk)O\n", + "alpha = round((60+20*9.81*1.5)/((1/12)*20*3**(2)+20*1.5*1.5),2) #[radians per second square]\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2\"\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\\n\"\n", + "\n", + "# Calculation Solution 3\n", + "# Using +ΣMO(clockwise) = IOalpha\n", + "alpha = round((60+20*9.81*1.5)/((1/3)*20*3**(2)),2) #[radians per second square]\n", + "\n", + "# Result Solution 3\n", + "print\"Solution 3\"\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\\n\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.11 Page No 744" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "alpha = 11.3 rad/s**(2)\n", + "\n", + "Solution 2\n", + "alpha = 11.3 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.11\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "m = 60 #[kilogram]\n", + "k = 0.25 #[meters]\n", + "\n", + "# Calculation Solution 1\n", + "IO = m*k**(2)\n", + "# Using +ΣMO(counterclockwise) = IOalpha, +ΣFy(upward) = m(aG)y and +a(counterclockwise) = alpha*r\n", + "a = np.array([[0.4,0,-IO],[1,20,0],[0,1,-0.4]])\n", + "b = np.array([0,20*9.81,0])\n", + "x = np.linalg.solve(a, b)\n", + "T = round(x[0],2) #[Newton]\n", + "a = round(x[1],2) #[meters per second square]\n", + "alpha = round(x[2],1) #[radians per second square]\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1\"\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\\n\"\n", + "\n", + "# Calculation Solution 2\n", + "# Using +ΣMO(clockwise) = Σ(Mk)O\n", + "alpha = round((20*9.81*0.4)/(3.75+20*0.4*0.4),1) #[radians per second square]\n", + "\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2\"\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.12 Page No 745" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "On = 1600.0 N\n", + "Ot = 223.9 N\n", + "alpha = 10.66 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.12\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Using +ΣFn(left) = mw**(2)rG, +ΣFt(upward) = m*alpha*rG and +ΣMG(clockwise) = IG*alpha\n", + "a = np.array([[1,0,0],[0,1,50*0.5],[0,0.5,-18]])\n", + "b = np.array([50*8**(2)*0.5,50*9.81,-80])\n", + "x = np.linalg.solve(a, b)\n", + "On = round(x[0],2) #[Newton]\n", + "Ot = round(x[1],2) #[Newton]\n", + "alpha = round(x[2],2) #[radians per second square]\n", + "\n", + "\n", + "# Result\n", + "print\"On = \",(On),\"N\"\n", + "print\"Ot = \",(Ot),\"N\" # Correction in the textbook\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.14 Page No 754" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "alpha = 10.3 rad/s**(2)\n", + "\n", + "Solution 2\n", + "alpha = 10.3 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.14\n", + "import numpy as np\n", + "\n", + "# Calculation Solution 1\n", + "IG = 8*0.35**(2) #[kilogram meter square]\n", + "# Using +ΣFy(upward) = m(aG)y, +ΣMG(clockwise) = IG*alpha and +aG(clockwise) = alpha*r\n", + "a = np.array([[1,-8,0],[0.5,0,IG],[0,1,-0.5]])\n", + "b = np.array([-100+78.48,100*0.2,0])\n", + "x = np.linalg.solve(a, b)\n", + "T = round(x[0],2) #[Newton]\n", + "aG = round(x[1],2) #[meters per second square]\n", + "alpha = round(x[2],1) #[radians per second square]\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1\"\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\\n\"\n", + "\n", + "# Calculation Solution 2\n", + "# Using +ΣMA(clockwise) = Σ(Mk)A and aG = 0.5*alpha\n", + "alpha = round((100*0.7-78.48*0.5)/(0.980+8*0.5*0.5),1) #[radians per second square]\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2\"\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.15 Page No 755" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aG = 2.453 m/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.15\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Slipping\n", + "# Using +ΣFx(right) = m(aG)x, +ΣFy(upward) = m(aG)y, +ΣMG(clockwise) = IG*alpha and FA = 0.25*NA\n", + "a = np.array([[1,0,-5,0],[0,1,0,0],[1.25,0,0,2.45],[1,-0.25,0,0]])\n", + "b = np.array([0,5*9.81,35,0])\n", + "x = np.linalg.solve(a, b)\n", + "FA = round(x[0],2) #[Newton]\n", + "NA = round(x[1],2) #[Newton]\n", + "aG = round(x[2],3) #[meters per second square]\n", + "alpha = round(x[3],2) #[radians per second square]\n", + "\n", + "# Result\n", + "print\"aG = \",(aG),\"m/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.16 Page No 756" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "alpha = -0.428 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.16\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Slipping\n", + "# Using +ΣFx(right) = m(aG)x, +ΣFy(upward) = m(aG)y, +ΣMG(clockwise) = IG*alpha and FA = 0.25*NA\n", + "a = np.array([[1,0,100,0],[0,1,0,0],[1.5,0,0,-75],[1,-0.25,0,0]])\n", + "b = np.array([400,981,400,0])\n", + "x = np.linalg.solve(a, b)\n", + "FA = round(x[0],2) #[Newton]\n", + "NA = round(x[1],2) #[Newton]\n", + "aG = round(x[2],3) #[meters per second square]\n", + "alpha = round(x[3],3) #[radians per second square]\n", + "\n", + "# Result\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 17.17 Page No 757" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "alpha = 10.3 rad/s**(2)\n" + ] + } + ], + "source": [ + "# Ex 17.17\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Using +ΣMA(counterclockwise) = Σ(Mk)A, aGx = alpha*0.25 and aGy = alpha*0.1\n", + "a = np.array([[0.675,30*0.25,30*0.1],[0.25,-1,0],[0.1,0,-1]])\n", + "b = np.array([30*9.81*0.1,0,0])\n", + "x = np.linalg.solve(a, b)\n", + "alpha = round(x[0],1) #[radians per second square]\n", + "aGx = round(x[1],2) #[meters per second square]\n", + "aGy = round(x[2],2) #[meters per second square]\n", + "\n", + "# Result\n", + "print\"alpha = \",(alpha),\"rad/s**(2)\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_18_Planar_Kinetics_of_a_Rigid_Body_Work_and_Energy.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_18_Planar_Kinetics_of_a_Rigid_Body_Work_and_Energy.ipynb new file mode 100644 index 00000000..321b8558 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_18_Planar_Kinetics_of_a_Rigid_Body_Work_and_Energy.ipynb @@ -0,0 +1,429 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 18 Planar Kinetics of a Rigid Body Work and Energy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 18.1 Page No 768" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T = 4.96 J\n" + ] + } + ], + "source": [ + "# Ex 18.1\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration \n", + "mB = 6 #[kilogram]\n", + "mD = 10 #[kilogram]\n", + "mC = 12 #[kilogram]\n", + "\n", + "# Calculation\n", + "# Block\n", + "TB = (1/2)*mB*0.8**(2) #[Joules]\n", + "# Disk\n", + "TD = (1/2)*(1/2)*mD*0.1**(2)*8**(2) #[Joules]\n", + "# Cylinder\n", + "TC = (1/2)*12*0.4**(2)+(1/2)*(1/2)*mC*0.1**(2)*4**(2) #[Joules]\n", + "# Let T be total kinetic energy of system\n", + "T = TB+TD+TC #[Joules]\n", + "\n", + "# Result\n", + "print\"T = \",(T),\"J\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 18.2 Page No 772" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "U = 527.6 J\n" + ] + } + ], + "source": [ + "# Ex 18.2\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "M = 50 #[Newton meter]\n", + "P = 80 #[Newton]\n", + "\n", + "# Calculation\n", + "# Weight W\n", + "UW = 98.1*1.5 #[Joules]\n", + "# Couple Moment\n", + "UM = M*math.pi/2 #[Joules]\n", + "# Spring Force Fs\n", + "Us = -((1/2)*30*2.25**(2)-(1/2)*30*0.25**(2)) #[Joules]\n", + "# Force P\n", + "UP = P*4.712 #[Joules]\n", + "# let U be total work\n", + "U = round(UW+UM+Us+UP,1) #[Joules]\n", + "\n", + "# Result\n", + "print\"U = \",(U),\"J\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 18.3 Page No 775" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta = 2.73 rev\n" + ] + } + ], + "source": [ + "# Ex 18.3\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "F = 10 #[Newton]\n", + "w = 20 #[radians per second]\n", + "M = 5 #[Newton meter]\n", + "\n", + "# Calculation\n", + "# Kinetic Energy\n", + "T1 = 0 #[Joules]\n", + "T2 = (1/2)*(1/2)*30*(0.2**(2))*(w**(2)) #[Joules]\n", + "# Using principle of Work and Energy\n", + "theta = (T2-T1)/(M+F*0.2) #[radians]\n", + "theta = round((theta*1)/(2*math.pi),2) #[rev]\n", + "\n", + "# Result\n", + "print\"theta = \",(theta),\"rev\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 18.4 Page No 776" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FdashT = 0.0 kN\n", + "NdashT = 4.24 kN\n" + ] + } + ], + "source": [ + "# Ex 18.4\n", + "import math\n", + "\n", + "# Calculation\n", + "w2 = math.sqrt((700*9.81*0.05359)/63.875) #[radians per second]\n", + "# Using +ΣFn(upward) = m(aG)n\n", + "NT = 700*9.81+700*2.40**(2)*0.4 #[kilo Newton]\n", + "# Using +ΣMO = IO*alpha\n", + "alpha = 0/(700*0.15**(2)+700*0.4**(2)) #[radians per second square]\n", + "# Using +ΣFt(left) = m(aG)t and (aG)t = 0.4*alpha\n", + "FT = 700*0.4*alpha #[kilo Newton]\n", + "# there are two tines to support the load\n", + "FdashT = 0 #[Newton]\n", + "NdashT = NT/2 #[Newton]\n", + "\n", + "# Result\n", + "print\"FdashT = \",(FdashT/1000),\"kN\"\n", + "print\"NdashT = \",round((NdashT/1000),2),\"kN\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 18.5 Page No 778" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w2 = 1.48 rad/s\n" + ] + } + ], + "source": [ + "# Ex 18.5\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "M = 75 #[Newton meter]\n", + "k = 50 #[Newton per meter]\n", + "W = 20 #[kilogram]\n", + "\n", + "# Calculation\n", + "# Using Principle of work and energy\n", + "w2 = round(math.sqrt((M*0.625-(1/2)*k*1**(2))/10),2) #[radians per second]\n", + "\n", + "# Result\n", + "print\"w2 = \",(w2),\"rad/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 18.6 Page No 779" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w2 = 6.11 rad/s\n" + ] + } + ], + "source": [ + "# Ex 18.6\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "P = 50 #[Newton]\n", + "\n", + "# Calculation\n", + "# Using Principle of work and energy\n", + "w2 = round(math.sqrt((98.1*(0.4-0.4*math.cos(math.pi*45/180))+50*0.8*math.sin(math.pi*45/180))/(1.067)),2) #[radians per second]\n", + "\n", + "# Result\n", + "print\"w2 = \",(w2),\"rad/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 18.7 Page No 787" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w2 = 4.81 rad/s\n" + ] + } + ], + "source": [ + "# Ex 18.7\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "m = 10 #[kilogram]\n", + "k = 800 #[Newton per meter]\n", + "\n", + "# Calculation\n", + "# Potential Energy\n", + "V1 = round(-98.1*(0.2*math.sin(math.pi*30/180))+(1/2)*k*(0.4*math.sin(math.pi*30/180))**(2),2) #[Joules]\n", + "# CG is located at datum\n", + "V2 = 0 #[Joules]\n", + "# Kinetic Energy\n", + "# Since the rod is released from rest position 1\n", + "T1 = 0 #[Joules]\n", + "# Using principle of conservation of energy\n", + "w2 = round(math.sqrt((T1+V1-V2)/0.267),2) #[radians per second]\n", + "\n", + "# Result\n", + "print\"w2 = \",(w2),\"rad/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 18.8 Page No 788" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w2 = 3.9 rad/s\n" + ] + } + ], + "source": [ + "# Ex 18.8\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "k = 30 #[Newton per meter]\n", + "\n", + "# Calculation\n", + "V1 = (1/2)*k*(math.sqrt(0.9**(2)+1.2**(2))-0.3)**(2) #[Joules]\n", + "V2 = (1/2)*k*(1.2-0.3)**(2) #[Joules]\n", + "# The disk is releaseg from rest \n", + "T1 = 0 #[Joules]\n", + "# Using principle of conservation of energy\n", + "w2 = round(math.sqrt((T1+V1-V2)/0.6227),2) #[radians per second]\n", + "\n", + "# Result\n", + "print\"w2 = \",(w2),\"rad/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 18.9 Page No 789" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wR2 = 6.52 rad/s\n" + ] + } + ], + "source": [ + "# Ex 18.9\n", + "import math\n", + "\n", + "# Calculation\n", + "# Potential energy\n", + "V1 = 49.05*0.3*math.sin(math.pi*60/180) #[Joules]\n", + "# At position 2 weight of rod and disk have zero potential energy\n", + "V2 = 0 #[Joules]\n", + "# Kinetic energy\n", + "# Since the entire system is at rest\n", + "T1 = 0 #[Joules]\n", + "# Using conservation of energy\n", + "wR2 = round(math.sqrt((T1+V1-V2)/0.3),2) #[radians per second]\n", + "\n", + "# Result\n", + "print\"wR2 = \",(wR2),\"rad/s\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_19_Planar_Kinetics_of_a_Rigid_Body_Impulse_and_Momentum.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_19_Planar_Kinetics_of_a_Rigid_Body_Impulse_and_Momentum.ipynb new file mode 100644 index 00000000..d7c43858 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_19_Planar_Kinetics_of_a_Rigid_Body_Impulse_and_Momentum.ipynb @@ -0,0 +1,349 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 19 Planar Kinetics of a Rigid Body Impulse and Momentum" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 19.1 Page No 802" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HG = 2.5 m**(2)/s\n", + "HB = 7.5 m**(2)/s\n", + "HG = 3.85 m**(2)/s\n", + "HIC = 15.4 m**(2)/s\n" + ] + } + ], + "source": [ + "# Ex 19.1\n", + "from __future__ import division \n", + "\n", + "# Variable Declaration\n", + "md = 10 #[kilogram]\n", + "mb = 5 #[kilogram]\n", + "\n", + "# Calculation Disk\n", + "# Using +HG(clockwise) = IG*w\n", + "HG = (1/2)*md*0.25**(2)*8 #[meters square per second]\n", + "# Using +HB(clockwise) = IG*w +m(vG)rG\n", + "HB = HG+md*2*0.25 #[meters square per second]\n", + "\n", + "# Result Disk\n", + "print\"HG = \",(HG),\"m**(2)/s\"\n", + "print\"HB = \",(HB),\"m**(2)/s\"\n", + "\n", + "\n", + "# Calculation Bar\n", + "# Using +HG(clockwise) = IG*w\n", + "HG = round((1/12)*mb*4**(2)*0.5774,2) #[meters square per second]\n", + "HIC = round(HG+2*mb*1.155,2) #[meters square per second]\n", + "\n", + "# Result Bar\n", + "print\"HG = \",(HG),\"m**(2)/s\"\n", + "print\"HIC = \",(HIC),\"m**(2)/s\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 19.2 Page No 806" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax = 0.0 N\n", + "Ay = 140.0 N\n", + "w2 = 69.7 rad/s\n" + ] + } + ], + "source": [ + "# Ex 19.2\n", + "import numpy as np\n", + "from __future__ import division \n", + "\n", + "# Calculation\n", + "IA = round((1/2)*(100/9.81)*0.3**(2),3) #[kilogram meter square]\n", + "# Using principle of impulse and momentum\n", + "a = np.array([[2,0,0],[0,2,0],[0,0,IA]])\n", + "b = np.array([0,100*2+40*2,4*2+40*2*0.3])\n", + "x = np.linalg.solve(a, b)\n", + "Ax = round(x[0],1) #[Newton]\n", + "Ay = round(x[1],1) #[Newton]\n", + "w2 = round(x[2],1) #[radians per second]\n", + "\n", + "# Result\n", + "print\"Ax = \",(Ax),\"N\"\n", + "print\"Ay = \",(Ay),\"N\"\n", + "print\"w2 = \",(w2),\"rad/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 19.3 Page No 807" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w2 = 1.05 rad/s\n" + ] + } + ], + "source": [ + "# Ex 19.3\n", + "import numpy as np\n", + "from __future__ import division \n", + "\n", + "# Calculation\n", + "IG = round(100*0.35**(2),3) #[kilogram meter square]\n", + "# Using principle of impulse and momentum\n", + "a = np.array([[1,100*0.75],[0.75,-12.25]])\n", + "b = np.array([62.5,-25])\n", + "x = np.linalg.solve(a, b)\n", + "w2 = round(x[1],2) #[radians per second]\n", + "\n", + "# Result\n", + "\n", + "print\"w2 = \",(w2),\"rad/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 19.4 Page No 808" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "vB2 = 13.0 m/s\n", + "\n", + "Solution 2\n", + "vB2 = 26.0725 m/s\n" + ] + } + ], + "source": [ + "# Ex 19.4\n", + "import numpy as np\n", + "from __future__ import division \n", + "\n", + "# Variable Declaration\n", + "IA = 0.40 #[kilogram meter square]\n", + "\n", + "# Calculation Solution 1\n", + "# Using principle of impulse and momentum\n", + "a = np.array([[3*0.2,-IA/0.2],[3,6]])\n", + "b = np.array([-IA*10,6*2+58.86*3])\n", + "x = np.linalg.solve(a, b)\n", + "T = round(x[0],1) #[Newton]\n", + "vB2 = round(x[1],1) #[meters per second]\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1\"\n", + "print\"vB2 = \",(vB2),\"m/s\\n\"\n", + "\n", + "# Calculation Solution 2\n", + "# Using principle of angular impulse and momentum\n", + "vB2 = (6*2*0.2+0.4*10+58.86*3*0.2)/(6*0.2+0.4*5*0.2) #[meters per second]\n", + "\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2\"\n", + "print\"vB2 = \",(vB2),\"m/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 19.6 Page No 816" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vG1 = 0.73 m/s\n" + ] + } + ], + "source": [ + "# Ex 19.5\n", + "from __future__ import division\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "IG = 0.156 #[kilogram meter square]\n", + "\n", + "# Calculation\n", + "# Using principle of conservation of energy\n", + "vG2 = math.sqrt((98.1*0.03)/((1/2)*10+(1/2)*IG*25)) #[meters per second]\n", + "# vG2 = 0.892*vG1\n", + "vG1 = round(vG2/0.892,3) #[meters per second]\n", + "\n", + "# Result\n", + "print\"vG1 = \",(vG1),\"m/s\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 19.7 Page No 817" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w2 = 0.622 rad/s\n" + ] + } + ], + "source": [ + "# Ex 19.7\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Σ(HO)1 = Σ(HO)2, vG2 = 0.5*w2 and vB2 = 0.75*w2\n", + "w2 = round((1.039)/(0.003*0.75+2.5*0.5+0.417),3) #[radians per second]\n", + "\n", + "# Result\n", + "print\"w2 = \",(w2),\"rad/s\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 19.8 Page No 821" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w2 = 3.65 rad/s\n" + ] + } + ], + "source": [ + "# Ex 19.8\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Using principle of conservation of angular momentum and coefficient of restitution\n", + "a = np.array([[1.67,0.5],[0.5,-1]])\n", + "b = np.array([5,4])\n", + "x = np.linalg.solve(a, b)\n", + "w2 = round(x[0],2) #[radians per second]\n", + "vB2 = round(x[1],2) #[meters per second]\n", + "\n", + "# Result\n", + "print\"w2 = \",(w2),\"rad/s\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_1_General_Principles.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_1_General_Principles.ipynb new file mode 100644 index 00000000..62d27f1f --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_1_General_Principles.ipynb @@ -0,0 +1,117 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 1 General Principles" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 1.1 Page No 10 " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Part(a)\n", + "(10 mN)(5 GN) = 50 kilo Newton square\n", + "\n", + "Part(b)\n", + "(100 mm)(0.5 MN square) = 25 Gigameter Newton square\n", + "\n", + "Part(c)\n", + "(50 MN cube)(500 Gg) = 100 Kilo Newton cube per kg\n" + ] + } + ], + "source": [ + "# Example Number 1.1\n", + "\n", + "# Part(a)\n", + "# Variable Declaration\n", + "a = 10 # [micro Newton(mN)]\n", + "b = 5 # [Giga Newton(GN)]\n", + "\n", + "# Calculation\n", + "# We have to find c = a * b\n", + "c = 10*5 # [micro Newton(mN)*Giga Newton(GN)]\n", + "c = (10*10**(-3))*(5*10**(9)) # [N**(2)]\n", + "c = (10*10**(-3))*(5*10**(9))*10**(-6) #[kN**(2)]\n", + "\n", + "#Result\n", + "print\"Part(a)\"\n", + "print \"(10 mN)(5 GN) = \",int(c),\"kilo Newton square\\n\"\n", + "\n", + "# Part(b)\n", + "# Variable Declaration\n", + "a = 100 #[millimeter(mm)]\n", + "b = 0.5**(2) #[mega Newton square(MN**(2))]\n", + "\n", + "# Calculation\n", + "# We have to find c = a * b\n", + "c = (100*10**(-3))*(0.25*10**(12)) #[m.N**(2)]\n", + "c = (100*10**(-3))*(0.25*10**(12))*10**(-9) #[Gm.N**(2)]\n", + "\n", + "#Result\n", + "print\"Part(b)\"\n", + "print \"(100 mm)(0.5 MN square) = \",int(c),\"Gigameter Newton square\\n\"\n", + "\n", + "# Part(c) (Correction in the question (50 MN cube)(500 Gg))\n", + "# Variable Declaration\n", + "a = 50 #[mega newton cube((MN)**(3))]\n", + "b = 500 #[gigagram(Gg)]\n", + "\n", + "# Calculation\n", + "# We have to find c = a / b\n", + "c = 50*(10**(6))**3 / 500*10**(6) #[N**(3)/kg]\n", + "c = (50*((10**(6))**3) / (500*10**(6)))*10**(-9) #[kN**(3)/kg]\n", + "\n", + "#Result\n", + "print\"Part(c)\"\n", + "print \"(50 MN cube)(500 Gg) = \",int(c),\"Kilo Newton cube per kg\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_2_Force_Vectors.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_2_Force_Vectors.ipynb new file mode 100644 index 00000000..8b8efd6a --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_2_Force_Vectors.ipynb @@ -0,0 +1,1058 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 2 : Force Vectors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.1 Page No. 20" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Resultant Force F_R = 213 N\n", + "theta = 39.8 degrees\n", + "phi = 54.8 degrees\n" + ] + } + ], + "source": [ + "#Example 2.1\n", + "import math\n", + "\n", + "# The parallelogram law of addition is shown in Fig.2-10b\n", + "\n", + "# F_R is determined using law of cosines\n", + "\n", + "#Calculation\n", + "F_R = math.sqrt((100**(2))+(150**(2))-2*100*150*math.cos(115*math.pi/180)) #[Newton]\n", + "\n", + "#Result\n", + "print\"Resultant Force F_R = \",int(round(F_R)),\"N\"\n", + "\n", + "# Angle theta is determined by law of sines\n", + "\n", + "#Calculation\n", + "theta = math.asin(150*0.9063/212.6) #[Radians]\n", + "\n", + "#Result\n", + "print \"theta = \",(round(math.degrees(theta),1)),\"degrees\"\n", + "\n", + "#The direction of phi as masured from horizontal is given by\n", + "phi = 39.8 + 15.0 #[Degrees]\n", + "print\"phi = \",phi,\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.2 Page No. 21" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F_x = 1532 N\n", + "F_y = 1285 N\n", + "F_x_dash = 1769 N\n", + "F_y = 2170 N\n" + ] + } + ], + "source": [ + "# Example 2.2\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "F = 2000 #[newton]\n", + "# In each case parallelogram law is used to resolve F into its two components\n", + "\n", + "# Part(a)\n", + "# The vector addition F = F_x + F_y is shown in fig2-11b\n", + "# Calculation\n", + "F_x = F*math.cos(40*math.pi/180) #[Newton]\n", + "F_y = F*math.sin(40*math.pi/180) #[Newton]\n", + "\n", + "# Result\n", + "print\"F_x = \",int((F_x)),\"N\"\n", + "print\"F_y = \",int((F_y)),\"N\"\n", + "\n", + "# Part(b)\n", + "# The vector addition F = F_x_dash + F_y is shown in fig2-11b\n", + "# Calculation\n", + "F_x_dash = F*math.sin(50*math.pi/180)/math.sin(60*math.pi/180) #[Newton]\n", + "F_y = F*math.sin(70*math.pi/180)/math.sin(60*math.pi/180) #[Newton]\n", + "\n", + "# Result\n", + "print\"F_x_dash = \",int((F_x_dash)),\"N\"\n", + "print\"F_y = \",int((F_y)),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.3 Page No. 22" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta = 76.1 degrees\n" + ] + } + ], + "source": [ + "# Example 2.3\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# The angle phi can be determined using law of cosines\n", + "\n", + "# Calculation\n", + "phi = math.asin((400/500)*math.sin(60*math.pi/180)) #[Radians]\n", + "phi = math.degrees(phi) #[Degrees]\n", + "theta = 180-60-phi #[Degrees]\n", + "\n", + "# Result\n", + "print\"theta = \",round(theta,1),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.4 Page No. 23" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Part(a)\n", + "F1 = 653 N\n", + "F2 = 446 N\n", + "\n", + "Part(b)\n", + "F1 = 940 N\n", + "F2 = 342 N\n" + ] + } + ], + "source": [ + "# Example 2.4\n", + "import math\n", + "\n", + "# Part(a) Refer fig 2-13b\n", + "# Using parallelogram law\n", + "\n", + "# Calculation\n", + "F1 = 1000*math.sin(30*math.pi/180)/math.sin(130*math.pi/180) #[Newton]\n", + "F2 = 1000*math.sin(20*math.pi/180)/math.sin(130*math.pi/180) #[Newton]\n", + "\n", + "# Result\n", + "print\"Part(a)\"\n", + "print\"F1 = \",int(round(F1,0)),\"N\"\n", + "print\"F2 = \",int(round(F2,0)),\"N\\n\"\n", + "\n", + "# Part(b) Refer fig 2-13d\n", + "\n", + "# Calculation\n", + "F1 = 1000*math.sin(70*math.pi/180) #[Newton]\n", + "F2 = 1000*math.cos(70*math.pi/180) #[Newton]\n", + "\n", + "# Result\n", + "print\"Part(b)\"\n", + "print\"F1 = \",int(round(F1,0)),\"N\"\n", + "print\"F2 = \",int(round(F2,0)),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.5 Page No. 31" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F1_x = -100 N\n", + "F1_y = 173 N\n", + "F2_x = 240 N\n", + "F2_y = 100 N\n" + ] + } + ], + "source": [ + "# Example 2.5\n", + "import math\n", + "# F1_x acts in -x direction and F1_y acts in +y direction Refer fig 2-17b\n", + "\n", + "# Calculation\n", + "F1_x = -200*math.sin(30*math.pi/180) #[Newton]\n", + "F1_y = 200*math.cos(30*math.pi/180) #[Newton]\n", + "\n", + "# Result\n", + "print\"F1_x = \",int(round(F1_x,0)),\"N\"\n", + "print\"F1_y = \",int(round(F1_y,0)),\"N\"\n", + "\n", + "# F2 is resolved into its x and y components Refer fig 2-17c\n", + "\n", + "# Calculation\n", + "F2_x = 260*(12/13) #[Newton]\n", + "F2_y = 260*(5/13) #[Newton]\n", + "\n", + "# Result\n", + "print\"F2_x = \",int(round(F2_x,0)),\"N\"\n", + "print\"F2_y = \",int(round(F2_y,0)),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.6 Page No. 32" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FR_x = 236.8 N\n", + "FR_y = 582.8 N\n", + "FR = 629 N\n", + "Theta = 67.9 degrees\n" + ] + } + ], + "source": [ + "# Example 2.6\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "F1 = 600 #[Newton]\n", + "F2 = 400 #[Newton]\n", + "\n", + "# We resolve each force into x and y components Refer fig 2-18b\n", + "# Let FR be resultant force\n", + "# Let FR_x be resultant force along x direction\n", + "# Let FR_y be resultant force along y direction\n", + "\n", + "# Calculation\n", + "FR_x = F1*math.cos(30*math.pi/180) - F2*math.sin(45*math.pi/180) #[Newton]\n", + "FR_y = F1*math.sin(30*math.pi/180) + F2*math.cos(45*math.pi/180) #[Newton]\n", + "FR = math.sqrt(round(FR_x,1)**(2)+round(FR_y,1)**(2)) #[Newton]\n", + "theta = math.atan(round(FR_y,1)/round(FR_x,1)) #[Radians]\n", + "theta = math.degrees(theta) #[Degrees]\n", + "\n", + "# Result\n", + "print\"FR_x = \",round(FR_x,1),\"N\"\n", + "print\"FR_y = \",round(FR_y,1),\"N\"\n", + "print\"FR = \",int(round(FR,0)),\"N\"\n", + "print\"Theta = \",round(theta,1),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 2.7 Page No. 33" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F_R_x = -383.2 N\n", + "F_R_y = 296.8 N\n", + "F_R = 485 N\n", + "Theta = 37.8 degrees\n" + ] + } + ], + "source": [ + "# Example 2.7\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "F1 = 400 #[Newton]\n", + "F2 = 250 #[Newton]\n", + "F3 = 200 #[Newton]\n", + "\n", + "# We resolve each force into x and y components Refer fig 2-18b\n", + "# Let F_R be resultant force\n", + "# Let F_R_x be resultant force along x direction\n", + "# Let F_R_y be resultant force along y direction\n", + "\n", + "# Calculation\n", + "F_R_x = -F1 + F2*math.sin(45*math.pi/180) - F3*(4/5) #[Newton]\n", + "F_R_y = F2*math.cos(45*math.pi/180) + F3*(3/5) #[Newton]\n", + "F_R = math.sqrt(round(F_R_x,1)**(2)+round(F_R_y,1)**(2)) #[Newton]\n", + "theta = math.atan(abs(round(F_R_y,1)/round(F_R_x,1))) #[Radians]\n", + "theta = math.degrees(theta) #[Degrees]\n", + "\n", + "# Result\n", + "print\"F_R_x = \",round(F_R_x,1),\"N\"\n", + "print\"F_R_y = \",round(F_R_y,1),\"N\"\n", + "print\"F_R = \",int(round(F_R,0)),\"N\"\n", + "print\"Theta = \",round(theta,1),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.8 Page No. 41" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cos_alpha = +/- 0.5\n", + "F = 100 N\n" + ] + } + ], + "source": [ + "# Example 2.8\n", + "import math\n", + "\n", + "# Variable declaration\n", + "beta = 60 #[Degrees]\n", + "gamma = 45 #[Degrees]\n", + "f = 100 #[Newton]\n", + "\n", + "# Calculation\n", + "cos_alpha = math.sqrt(1-(math.cos(beta*math.pi/180)**(2))-(math.cos(gamma*math.pi/180)**(2))) #[Radians]\n", + "alpha1 = math.degrees(math.acos(+cos_alpha)) #[Degrees]\n", + "alpha2 = math.degrees(math.acos(-cos_alpha)) #[Degrees]\n", + "Fx = f*math.cos(alpha1*math.pi/180) #[Newton]\n", + "Fy = f*math.cos(beta*math.pi/180) #[Newton]\n", + "Fz = f*math.cos(gamma*math.pi/180) #[Newton]\n", + "F = math.sqrt(round(Fx**(2),1)+round(Fy**(2),1)+round(Fz**(2),1)) #[Newton]\n", + "\n", + "# Result\n", + "print\"cos_alpha = +/-\",(cos_alpha)\n", + "print\"F = \",int(F),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 2.9 Page No. 42" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Resultant Force FR = 191.0 N\n", + "alpha = 74.8 degrees\n", + "beta = 102.1 degrees\n", + "gamma = 19.5 degrees\n" + ] + } + ], + "source": [ + "# Example 2.9\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable declaration\n", + "\n", + "F1_x = 0 #[Newton]\n", + "F1_y = 60 #[Newton]\n", + "F1_z = 80 #[Newton]\n", + "F2_x = 50 #[Newton]\n", + "F2_y = -100 #[Newton]\n", + "F2_z = 100 #[Newton]\n", + "\n", + "# Calculation\n", + "FR_x = F1_x + F2_x #[Newton]\n", + "FR_y = F1_y + F2_y #[Newton]\n", + "FR_z = F1_z + F2_z #[Newton]\n", + "\n", + "# Let F_R be resultant force\n", + "FR = round(math.sqrt(FR_x**(2)+FR_y**(2)+FR_z**(2)),1)\n", + "\n", + "# The coordinate direction angles alpha,beta and gamma are determined from components of unit vector along direction of F_R\n", + "cos_alpha = FR_x/FR\n", + "cos_beta = FR_y/FR\n", + "cos_gamma = FR_z/FR\n", + "alpha = round(math.degrees(math.acos(cos_alpha)),1) #[Degrees]\n", + "beta = round(math.degrees(math.acos(cos_beta)),1) #[Degrees]\n", + "gamma = round(math.degrees(math.acos(cos_gamma)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"Resultant Force FR = \",(FR),\"N\"\n", + "print\"alpha = \",(alpha),\"degrees\"\n", + "print\"beta = \",(beta),\"degrees\"\n", + "print\"gamma = \",(gamma),\"degrees\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.10 Page No. 43" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F1_x = 354 N\n", + "F1_y = 354 N\n", + "F1_z = 866 N\n", + "F1 = 1000 N\n", + "\n", + "F2_x = 1.06 kN\n", + "F2_y = 1.837 kN\n", + "F2_z = 2.121 kN\n", + "F2 = 3000 N\n" + ] + } + ], + "source": [ + "# Example 2.10\n", + "import math\n", + "\n", + "# For F1\n", + "\n", + "# Calculation\n", + "F1_z = int(round(1000*math.sin(60*math.pi/180),0)) #[Newton]\n", + "F1_dash = int(round(1000*math.cos(60*math.pi/180),0)) #[Newton]\n", + "F1_x = int(round(F1_dash*math.cos(45*math.pi/180),0)) #[Newton]\n", + "F1_y = int(round(F1_dash*math.sin(45*math.pi/180),0)) #[Newton]\n", + "\n", + "# F1_y has direction defined by -j\n", + "F1 = int(round(math.sqrt(F1_x**(2)+(-F1_y)**(2)+F1_z**(2)),0)) #[Newton]\n", + "\n", + "# u1 is unit vector along F1\n", + "u1_x = round(F1_x/F1,3)\n", + "u1_y = round(F1_y/F1,3)\n", + "u1_z = round(F1_z/F1,3)\n", + "alpha1 = round(math.degrees(math.acos(u1_x)),1) #[Degrees]\n", + "betaa1 = round(math.degrees(math.acos(u1_y)),1) #[Degrees]\n", + "gamma1 = round(math.degrees(math.acos(u1_z)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"F1_x = \",F1_x,\"N\"\n", + "print\"F1_y = \",F1_y,\"N\"\n", + "print\"F1_z = \",F1_z,\"N\"\n", + "print\"F1 = \",F1,\"N\\n\"\n", + "\n", + "# For F2\n", + "\n", + "# Calculation\n", + "F2_z = int(round(3000*math.sin(45*math.pi/180),0)) #[Newton]\n", + "F2_dash = int(round(3000*math.cos(45*math.pi/180),0)) #[Newton]\n", + "F2_x = int(round(F2_dash*math.sin(30*math.pi/180),0)) #[Newton]\n", + "F2_y = int(round(F2_dash*math.cos(30*math.pi/180),0)) #[Newton]\n", + "\n", + "# F2_z has direction defined by -k\n", + "F2 = int(round(math.sqrt(F2_x**(2)+F2_y**(2)+(-F2_z)**(2)),-1)) #[Newton]\n", + "\n", + "# u1 is unit vector along F1\n", + "\n", + "u2_x = round(F2_x/F2,3)\n", + "u2_y = round(F2_y/F2,3)\n", + "u2_z = round(F2_z/F2,3)\n", + "alpha2 = round(math.degrees(math.acos(u2_x)),1) #[Degrees]\n", + "betaa2 = round(math.degrees(math.acos(u2_y)),1) #[Degrees]\n", + "gamma2 = round(math.degrees(math.acos(u2_z)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"F2_x = \",F2_x/1000,\"kN\"\n", + "print\"F2_y = \",F2_y/1000,\"kN\"\n", + "print\"F2_z = \",F2_z/1000,\"kN\"\n", + "print\"F2 = \",F2,\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.11 Page No. 44" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "alpha2 = 107.6 degrees\n", + "beta2 = 21.8 degrees\n", + "gamma2 = 77.6 degrees\n" + ] + } + ], + "source": [ + "# Example 2.11\n", + "import math\n", + "\n", + "# Variable declaration\n", + "\n", + "F1 = 300 #[Newton]\n", + "F2 = 700 #[Newton]\n", + "FR = 800 #[Newton]\n", + "alpha1 = 45 #[Degrees]\n", + "beta1 = 60 #[Degrees]\n", + "gamma1 = 120 #[Degrees]\n", + "\n", + "# Calculation\n", + "F1_x = round(F1*math.cos(alpha1*math.pi/180),1) #[Newton]\n", + "F1_y = round(F1*math.cos(beta1*math.pi/180),1) #[Newton]\n", + "F1_z = round(F1*math.cos(gamma1*math.pi/180),1) #[Newton]\n", + "\n", + "# FR acts along +y axis\n", + "FR_x = 0 #[Newton]\n", + "FR_y = 800 #[Newton]\n", + "FR_z = 0 #[Newton]\n", + "\n", + "# FR = F1 + F2\n", + "# F2 = FR - F1\n", + "F2_x = FR_x - F1_x #[Newton]\n", + "F2_y = FR_y - F1_y #[Newton]\n", + "F2_z = FR_z - F1_z #[Newton]\n", + "alpha2 = round(math.degrees(math.acos(F2_x/F2)),1) #[Degrees]\n", + "beta2 = round(math.degrees(math.acos(F2_y/F2)),1) #[Degrees]\n", + "gamma2 = round(math.degrees(math.acos(F2_z/F2)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"alpha2 = \",(alpha2),\"degrees\"\n", + "print\"beta2 = \",(beta2),\"degrees\"\n", + "print\"gamma2 = \",(gamma2),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.12 Page No. 49" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "alpha = 115.4 degrees\n", + "beta = 73.4 degrees\n", + "gamma = 31.0 degrees\n" + ] + } + ], + "source": [ + "# Example 2.12\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "A_x = 1 #[meters]\n", + "A_y = 0 #[meters]\n", + "A_z = -3 #[meters]\n", + "B_x = -2 #[meters]\n", + "B_y = 2 #[meters]\n", + "B_z = 3 #[meters]\n", + "\n", + "# Calculation\n", + "# r = B - A\n", + "r_x = B_x - A_x #[meters]\n", + "r_y = B_y - A_y #[meters]\n", + "r_z = B_z - A_z #[meters]\n", + "r = math.sqrt(r_x**(2)+r_y**(2)+r_z**(2))\n", + "\n", + "# Assume u to be a unit vector along r\n", + "u_x = r_x/r\n", + "u_y = r_y/r\n", + "u_z = r_z/r\n", + "alpha = round(math.degrees(math.acos(u_x)),1) #[Degrees]\n", + "beta = round(math.degrees(math.acos(u_y)),1) #[Degrees]\n", + "gamma = round(math.degrees(math.acos(u_z)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"alpha = \",(alpha),\"degrees\"\n", + "print\"beta = \",(beta),\"degrees\"\n", + "print\"gamma = \",(gamma),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 2.13 Page No. 51" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F_x = 30.0 N\n", + "F_y = -20.0 N\n", + "F_z = -60.0 N\n", + "alpha = 64.6 degrees\n", + "beta = 106.6 degrees\n", + "gamma = 149.0 degrees\n" + ] + } + ], + "source": [ + "# Example 2.13\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "A_x = 0 #[meters]\n", + "A_y = 0 #[meters]\n", + "A_z = 8 #[meters]\n", + "B_x = 3 #[meters]\n", + "B_y = -2 #[meters]\n", + "B_z = 2 #[meters]\n", + "\n", + "# Calculation\n", + "# r = B - A\n", + "r_x = B_x - A_x #[meters]\n", + "r_y = B_y - A_y #[meters]\n", + "r_z = B_z - A_z #[meters]\n", + "r = math.sqrt(r_x**(2)+r_y**(2)+r_z**(2))\n", + "\n", + "# Assume u to be a unit vector along r\n", + "u_x = r_x/r\n", + "u_y = r_y/r\n", + "u_z = r_z/r\n", + "\n", + "# Since F = 70 N and direction is specified by u\n", + "F_x = 70 * u_x #[Newton]\n", + "F_y = 70 * u_y #[Newton]\n", + "F_z = 70 * u_z #[Newton]\n", + "alpha = round(math.degrees(math.acos(u_x)),1) #[Degrees]\n", + "beta = round(math.degrees(math.acos(u_y)),1) #[Degrees]\n", + "gamma = round(math.degrees(math.acos(u_z)),1) #[Degrees]\n", + "\n", + "# Result\n", + "print\"F_x = \",(F_x),\"N\"\n", + "print\"F_y = \",(F_y),\"N\"\n", + "print\"F_z = \",(F_z),\"N\"\n", + "print\"alpha = \",(alpha),\"degrees\"\n", + "print\"beta = \",(beta),\"degrees\"\n", + "print\"gamma = \",(gamma),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.14 Page No. 52" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F_x = 313.5 N\n", + "F_y = 129.8 N\n", + "F_z = -367.3 N\n", + "F = 500.0 N\n" + ] + } + ], + "source": [ + "# Example 2.14\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "A_x = 0 #[meters]\n", + "A_y = 0 #[meters]\n", + "A_z = 2 #[meters]\n", + "B_x = 1.707 #[meters]\n", + "B_y = 0.707 #[meters]\n", + "B_z = 0 #[meters]\n", + "\n", + "# Calculation\n", + "# r = B - A\n", + "r_x = B_x - A_x #[meters]\n", + "r_y = B_y - A_y #[meters]\n", + "r_z = B_z - A_z #[meters]\n", + "r = math.sqrt(r_x**(2)+r_y**(2)+r_z**(2))\n", + "\n", + "# Assume u to be a unit vector along r\n", + "u_x = r_x/r\n", + "u_y = r_y/r\n", + "u_z = r_z/r\n", + "\n", + "# Since F = 500 N and direction is specified by u\n", + "F_x = round(500 * u_x,1) #[Newton]\n", + "F_y = round(500 * u_y,1) #[Newton]\n", + "F_z = round(500 * u_z,1) #[Newton]\n", + "F = round(math.sqrt(F_x**(2)+F_y**(2)+F_z**(2)),1) #[Newton]\n", + "\n", + "# Result\n", + "print\"F_x = \",(F_x),\"N\"\n", + "print\"F_y = \",(F_y),\"N\"\n", + "print\"F_z = \",(F_z),\"N\"\n", + "print\"F = \",(F),\"N\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 2.15 Page No. 53" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FR = 217.0 N\n" + ] + } + ], + "source": [ + "# Example 2.15\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "FAB = 100 #[Newton]\n", + "FAC = 120 #[Newton]\n", + "A_x = 0 #[meters]\n", + "A_y = 0 #[meters]\n", + "A_z = 4 #[meters]\n", + "B_x = 4 #[meters]\n", + "B_y = 0 #[meters]\n", + "B_z = 0 #[meters]\n", + "C_x = 4 #[meters]\n", + "C_y = 2 #[meters]\n", + "C_z = 0 #[meters]\n", + "\n", + "# Calculation(FAB)\n", + "rAB_x = B_x - A_x #[meters]\n", + "rAB_y = B_y - A_y #[meters]\n", + "rAB_z = B_z - A_z #[meters]\n", + "rAB = round(math.sqrt(rAB_x**(2)+rAB_y**(2)+rAB_z**(2)),2)\n", + "FAB_x = round(FAB*(rAB_x/rAB),1) #[Newton]\n", + "FAB_y = round(FAB*(rAB_y/rAB),1) #[Newton]\n", + "FAB_z = round(FAB*(rAB_z/rAB),1) #[Newton]\n", + "\n", + "# Calculation(FAC)\n", + "rAC_x = C_x - A_x #[meters]\n", + "rAC_y = C_y - A_y #[meters]\n", + "rAC_z = C_z - A_z #[meters]\n", + "rAC = round(math.sqrt(rAC_x**(2)+rAC_y**(2)+rAC_z**(2)),2)\n", + "FAC_x = round(FAC*(rAC_x/rAC),1) #[Newton]\n", + "FAC_y = round(FAC*(rAC_y/rAC),1) #[Newton]\n", + "FAC_z = round(FAC*(rAC_z/rAC),1) #[Newton]\n", + "\n", + "# FR = FAB + FAC\n", + "FR_x = FAB_x + FAC_x #[Newton]\n", + "FR_y = FAB_y + FAC_y #[Newton]\n", + "FR_z = FAB_z + FAC_z #[Newton]\n", + "FR = round(math.sqrt(FR_x**(2)+FR_y**(2)+FR_z**(2)),0)\n", + "print\"FR = \",(FR),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.16 Page No. 61" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FAB = 257.1 N\n", + "FAB_x = 73.5 N\n", + "FAB_y = 220.4 N\n", + "FAB_z = 110.2 N\n", + "Fp = 155.0 N\n" + ] + } + ], + "source": [ + "# Example 2.16\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "rB_x = 2 #[meters]\n", + "rB_y = 6 #[meters]\n", + "rB_z = 3 #[meters]\n", + "F_x = 0 #[Newton]\n", + "F_y = 300 #[Newton]\n", + "F_z = 0 #[Newton]\n", + "\n", + "# Calculation\n", + "F = math.sqrt(F_x**(2)+F_y**(2)+F_z**(2)) #[Newton]\n", + "# Let uB be unit vector defining direction of AB\n", + "rB = math.sqrt(rB_x**(2)+rB_y**(2)+rB_z**(2)) #[meters]\n", + "uB_x = rB_x/rB\n", + "uB_y = rB_y/rB\n", + "uB_z = rB_z/rB\n", + "\n", + "# The magnitude of component of F along AB is equal to dot product of F and unit vector uB \n", + "FAB = round(F_x*uB_x + F_y*uB_y + F_z*uB_z,1) #[Newton]\n", + "\n", + "# Expressing FAB in Cartesian form\n", + "FAB_x = round(FAB*uB_x,1) #[Newton]\n", + "FAB_y = round(FAB*uB_y,1) #[Newton]\n", + "FAB_z = round(FAB*uB_z,1) #[Newton]\n", + "FAB = round(math.sqrt(FAB_x**(2)+FAB_y**(2)+FAB_z**(2)),1) #[Newton]\n", + "\n", + "# Let Fp be perpendicular component\n", + "Fp_x = F_x - FAB_x #[Newton]\n", + "Fp_y = F_y - FAB_y #[Newton]\n", + "Fp_z = F_z - FAB_z #[Newton]\n", + "Fp = round(math.sqrt(F**(2)-FAB**(2)),0) #[Newton]\n", + "\n", + "# Result\n", + "print\"FAB = \",(FAB),\"N\"\n", + "print\"FAB_x = \",(FAB_x),\"N\"\n", + "print\"FAB_y = \",(FAB_y),\"N\"\n", + "print\"FAB_z = \",(FAB_z),\"N\"\n", + "print\"Fp = \",(Fp),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 2.17 Page No. 62" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta = 42.4 degrees\n", + "FBA = 59.1 N\n", + "Fp = 53.9 N\n" + ] + } + ], + "source": [ + "# Example 2.17\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "F = 80 #[Newton]\n", + "A_x = 0\n", + "A_y = 1\n", + "A_z = 0\n", + "B_x = 2\n", + "B_y = 3\n", + "B_z = -1\n", + "C_x = 2\n", + "C_y = 0\n", + "C_z = 0\n", + "\n", + "# Calculation\n", + "rBA_x = A_x - B_x \n", + "rBA_y = A_y - B_y\n", + "rBA_z = A_z - B_z\n", + "rBC_x = C_x - B_x \n", + "rBC_y = C_y - B_y\n", + "rBC_z = C_z - B_z\n", + "rBA = round(math.sqrt(rBA_x**(2)+rBA_y**(2)+rBA_z**(2)),2)\n", + "rBC = round(math.sqrt(rBC_x**(2)+rBC_y**(2)+rBC_z**(2)),2)\n", + "theta = round(math.degrees(math.acos((rBA_x*rBC_x+rBA_y*rBC_y+rBA_z*rBC_z)/(rBA*rBC))),1)\n", + "\n", + "# let uBA be unit vector along BA\n", + "uBA_x = rBA_x/rBA\n", + "uBA_y = rBA_y/rBA\n", + "uBA_z = rBA_z/rBA\n", + "F_x = round(F*(rBC_x/rBC),2) #[Newton]\n", + "F_y = round(F*(rBC_y/rBC),2) #[Newton]\n", + "F_z = round(F*(rBC_z/rBC),2) #[Newton]\n", + "\n", + "# FBA = F.uBA\n", + "FBA = round(F_x*uBA_x + F_y*uBA_y + F_z*uBA_z,1) #[Newton]\n", + "\n", + "# Since theta was calculated FBA can be calculated by FBA = F*cos(theta)\n", + "# Let Fp be perpendicular component\n", + "Fp = round(F*math.sin(theta*math.pi/180),1) #[Newton]\n", + "\n", + "# Result\n", + "print\"theta = \",(theta),\"degrees\"\n", + "print\"FBA = \",(FBA),\"N\"\n", + "print\"Fp = \",(Fp),\"N\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_3_Equilibrium_of_a_Particle.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_3_Equilibrium_of_a_Particle.ipynb new file mode 100644 index 00000000..aef96ff3 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_3_Equilibrium_of_a_Particle.ipynb @@ -0,0 +1,468 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 3 : Equilibrium of a Particle" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 3.2 Page No. 75" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TB = 4.9 kN\n", + "TD = 4.25 kN\n" + ] + } + ], + "source": [ + "# Example 3.2\n", + "import math\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "theta = 30 #[Degrees]\n", + "\n", + "# Calculation\n", + "# The two unknown magnitudes TB and TD can be obtained from two scalar equations of equilibrium ΣF_x = 0 and ΣF_y = 0\n", + "a = np.array([[math.cos(math.pi*theta/180),-1], [math.sin(math.pi*theta/180),0]])\n", + "b = np.array([0,2.452])\n", + "x = np.linalg.solve(a, b)\n", + "TB = round(x[0],2) #[kilo Newton]\n", + "TD = round(x[1],2) #[kilo Newton]\n", + "\n", + "# Result\n", + "print\"TB = \",(TB),\"kN\"\n", + "print\"TD = \",(TD),\"kN\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 3.3 Page No. 76" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TB = 54.6 N\n", + "TD = 38.6 N\n", + "TCD = 34.1 N\n", + "WB = 47.8 N\n" + ] + } + ], + "source": [ + "# Example 3.3\n", + "import math\n", + "import numpy as np\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "WA = 20 #[Newton]\n", + "\n", + "# Calculation\n", + "# The two unknown magnitudes TEG and TEC can be obtained from two scalar equations of equilibrium ΣF_x = 0 and ΣF_y = 0 at point E\n", + "a = np.array([[math.sin(math.pi*30/180),-math.cos(math.pi*45/180)], [math.cos(math.pi*30/180),-math.sin(math.pi*45/180)]])\n", + "b = np.array([0,20])\n", + "x = np.linalg.solve(a, b)\n", + "TEG = round(x[0],1) #[Newton]\n", + "TEC = round(x[1],1) #[Newton]\n", + "\n", + "# The two unknown magnitudes TCD and WB can be obtained from two scalar equations of equilibrium ΣF_x = 0 and ΣF_y = 0 at point C\n", + "a = np.array([[-(4/5),0], [3/5,-1]])\n", + "b = np.array([-38.6*math.cos(math.pi*45/180), -38.6*math.sin(math.pi*45/180)])\n", + "x = np.linalg.solve(a, b)\n", + "TCD = round(x[0],1) #[Newton]\n", + "WB = round(x[1],1) #[Newton]\n", + "\n", + "# Result\n", + "print\"TB = \",(TEG),\"N\"\n", + "print\"TD = \",(TEC),\"N\"\n", + "print\"TCD = \",(TCD),\"N\"\n", + "print\"WB = \",(WB),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 3.4 Page No. 77" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "lAC = 1.32 m\n" + ] + } + ], + "source": [ + "# Example 3.4\n", + "import math\n", + "import numpy as np\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "lAB_dash = 0.4 #[meter]\n", + "kAB = 300 #[Newton/meter]\n", + "\n", + "# Calculation\n", + "# Let W be weight of lamp\n", + "W = 8*9.81 #[Newton]\n", + "\n", + "# The two unknown magnitudes TAB and TAC can be obtained from two scalar equations of equilibrium ΣF_x = 0 and ΣF_y = 0 at point A\n", + "a = np.array([[1,-math.cos(math.pi*30/180)], [0,math.sin(math.pi*30/180)]])\n", + "b = np.array([0, 78.5])\n", + "x = np.linalg.solve(a, b)\n", + "TAB = round(x[0],1) #[Newton]\n", + "TAC = round(x[1],1) #[Newton]\n", + "\n", + "# Let sAB denote the stretch of string\n", + "sAB = TAB/kAB\n", + "\n", + "# Let lAB denote the stretch of string\n", + "lAB = lAB_dash + sAB\n", + "lAC = round((2 - lAB)/math.cos(math.pi*30/180),2)\n", + "\n", + "# Result\n", + "print\"lAC = \",(lAC),\"m\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 3.5 Page No. 84" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FB = 207.8 N\n", + "FC = 150.0 N\n", + "FD = 240.0 N\n", + "sAB = 41.6 mm\n" + ] + } + ], + "source": [ + "# Example 3.5\n", + "import math\n", + "import numpy as np\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "L = 90 #[Newton]\n", + "k = 5000 #[Newton/meter]\n", + "\n", + "# Calculation\n", + "# The three unknown magnitudes FB, FC and FD can be obtained from three scalar equations of equilibrium ΣF_x = 0,ΣF_y = 0 and ΣF_z = 0 at point A\n", + "a = np.array([[0,-4/5,math.sin(math.pi*30/180)], [1,0,-math.cos(math.pi*30/180)], [0,3/5,0]])\n", + "b = np.array([0, 0, 90])\n", + "x = np.linalg.solve(a, b)\n", + "FB = round(x[0],1) #[Newton]\n", + "FC = round(x[1],1) #[Newton]\n", + "FD = round(x[2],1) #[Newton]\n", + "\n", + "# Let sAB denote stretch of a string\n", + "sAB= round((FB*1000)/k,1) #[millimeter]\n", + "\n", + "# Result\n", + "print\"FB = \",(FB),\"N\"\n", + "print\"FC = \",(FC),\"N\"\n", + "print\"FD = \",(FD),\"N\"\n", + "print\"sAB = \",(sAB),\"mm\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 3.6 Page No. 85" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F = 300.0 N\n", + "alpha = 48.2 degrees\n", + "beta = 109.5 degrees\n", + "gamma = 48.2 degrees\n" + ] + } + ], + "source": [ + "# Example 3.6\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "B_x = -2 #[meter]\n", + "B_y = -3 #[meter]\n", + "B_z = 6 #[meter]\n", + "F1_x = 0 #[Newton]\n", + "F1_y = 400 #[Newton]\n", + "F1_z = 0 #[Newton]\n", + "F2_x = 0 #[Newton]\n", + "F2_y = 0 #[Newton]\n", + "F2_z = -800 #[Newton]\n", + "F3 = 700 #[Newton]\n", + "\n", + "# Calculation\n", + "# Let rB be unit vector along OB\n", + "rB_x = -2\n", + "rB_y = -3\n", + "rB_z = 6\n", + "rB = math.sqrt(rB_x**(2)+rB_y**(2)+rB_z**(2))\n", + "F3_x = F3*(rB_x/rB) #[Newton]\n", + "F3_y = F3*(rB_y/rB) #[Newton]\n", + "F3_z = F3*(rB_z/rB) #[Newton]\n", + "\n", + "# For equilibrium ΣF = 0 and F1+F2+F3+F = 0\n", + "F_x = 0 - (F1_x +F2_x +F3_x) #[Newton]\n", + "F_y = 0 - (F1_y +F2_y +F3_y) #[Newton]\n", + "F_z = 0 - (F1_z +F2_z +F3_z) #[Newton]\n", + "F = round(math.sqrt(F_x**(2)+F_y**(2)+F_z**(2)),1) #[Newton]\n", + "alpha = round(math.degrees(math.acos(F_x/F)),1) #[Degrees]\n", + "beta = round(math.degrees(math.acos(F_y/F)),1) #[Degrees]\n", + "gamma = round(math.degrees(math.acos(F_z/F)),1) #[Degrees]\n", + "\n", + "\n", + "# Result\n", + "print\"F = \",(F),\"N\"\n", + "print\"alpha = \",(alpha),\"degrees\"\n", + "print\"beta = \",(beta),\"degrees\"\n", + "print\"gamma = \",(gamma),\"degrees\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 3.7 Page No. 86" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FB = 23.6 N\n", + "FC = 23.6 N\n", + "FD = 15.0 N\n" + ] + } + ], + "source": [ + "# Example 3.7\n", + "import math\n", + "import numpy as np\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "B_x = -3 #[meter]\n", + "B_y = -4 #[meter]\n", + "B_z = 8 #[meter]\n", + "C_x = -3 #[meter]\n", + "C_y = 4 #[meter]\n", + "C_z = 8 #[meter]\n", + "\n", + "# Calculation\n", + "# let FB_x/FB = b_x, FB_y/FB = b_y, FB_z/FB = b_z \n", + "b_x = round(B_x/(math.sqrt(B_x**(2)+B_y**(2)+B_z**(2))),3) #[Newton]\n", + "b_y = round(B_y/(math.sqrt(B_x**(2)+B_y**(2)+B_z**(2))),3) #[Newton]\n", + "b_z = round(B_z/(math.sqrt(B_x**(2)+B_y**(2)+B_z**(2))),3) #[Newton]\n", + "\n", + "# let FC_x/FC = c_x, FC_y/FC = c_y, FC_z/FC = c_z \n", + "c_x = round(C_x/(math.sqrt(C_x**(2)+C_y**(2)+C_z**(2))),3) #[Newton]\n", + "c_y = round(C_y/(math.sqrt(C_x**(2)+C_y**(2)+C_z**(2))),3) #[Newton]\n", + "c_z = round(C_z/(math.sqrt(C_x**(2)+C_y**(2)+C_z**(2))),3) #[Newton]\n", + "\n", + "# let FD_x/FD = d_x, FD_y/FD = d_y, FD_z/FD = d_z \n", + "d_x = 1\n", + "d_y = 0\n", + "d_z = 0\n", + "\n", + "W_x = 0\n", + "W_y = 0\n", + "W_z = -40\n", + "\n", + "# The three unknown magnitudes FB, FC and FD can be obtained from three scalar equations of equilibrium ΣF_x = 0,ΣF_y = 0 and ΣF_z = 0 at point A\n", + "a = np.array([[b_x,c_x,d_x], [b_y,c_y,d_y], [b_z,c_z,d_z]])\n", + "b = np.array([0, 0, -W_z])\n", + "x = np.linalg.solve(a, b)\n", + "FB = round(x[0],1) #[Newton]\n", + "FC = round(x[1],1) #[Newton]\n", + "FD = round(x[2],1) #[Newton]\n", + "\n", + "# Result\n", + "print\"FB = \",(FB),\"N\"\n", + "print\"FC = \",(FC),\"N\"\n", + "print\"FD = \",(FD),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 3.8 Page No. 87" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FB = 693.2 N\n", + "FC = 812.7 N\n", + "FD = 861.6 N\n", + "s = 0.462 m\n" + ] + } + ], + "source": [ + "# Ex 3.8\n", + "import math\n", + "import numpy as np\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "W = 981 #[Newton]\n", + "D_x = -1 #[meter]\n", + "D_y = 2 #[meter]\n", + "D_z = 2 #[meter]\n", + "k = 1500 #[Newton meter]\n", + "\n", + "# Calculation\n", + "# let FB_x/FB = b_x, FB_y/FB = b_y, FB_z/FB = b_z \n", + "b_x = 1 \n", + "b_y = 0\n", + "b_z = 0\n", + "\n", + "# let FC_x/FC = c_x, FC_y/FC = c_y, FC_z/FC = c_z \n", + "c_x = math.cos(120*math.pi/180) #[Newton]\n", + "c_y = math.cos(135*math.pi/180) #[Newton]\n", + "c_z = math.cos(60*math.pi/180) #[Newton]\n", + "\n", + "# let FD_x/FD = d_x, FD_y/FD = d_y, FD_z/FD = d_z \n", + "d_x = round(D_x/(math.sqrt(D_x**(2)+D_y**(2)+D_z**(2))),3) #[Newton]\n", + "d_y = round(D_y/(math.sqrt(D_x**(2)+D_y**(2)+D_z**(2))),3) #[Newton]\n", + "d_z = round(D_z/(math.sqrt(D_x**(2)+D_y**(2)+D_z**(2))),3) #[Newton]\n", + "\n", + "W_x = 0 #[Newton]\n", + "W_y = 0 #[Newton]\n", + "W_z = -981 #[Newton]\n", + "\n", + "# The three unknown magnitudes FB, FC and FD can be obtained from three scalar equations of equilibrium ΣF_x = 0,ΣF_y = 0 and ΣF_z = 0 at point A\n", + "a = np.array([[b_x,c_x,d_x], [b_y,c_y,d_y], [b_z,c_z,d_z]])\n", + "b = np.array([0, 0, -W_z])\n", + "x = np.linalg.solve(a, b)\n", + "FB = round(x[0],1) #[Newton]\n", + "FC = round(x[1],1) #[Newton]\n", + "FD = round(x[2],1) #[Newton]\n", + "\n", + "# Let stretch of spring be denoted by s\n", + "s = round(FB/k,3)\n", + "\n", + "# Result\n", + "print\"FB = \",(FB),\"N\"\n", + "print\"FC = \",(FC),\"N\"\n", + "print\"FD = \",(FD),\"N\"\n", + "print\"s = \",(s),\"m\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_4_Force_System_Resultants.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_4_Force_System_Resultants.ipynb new file mode 100644 index 00000000..7de45a57 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_4_Force_System_Resultants.ipynb @@ -0,0 +1,1263 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 4 : Force System Resultants" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.1 Page No 98" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fig 4-4a MO = 200 N.m(clockwise)\n", + "Fig 4-4b MO = 37.5 N.m(clockwise)\n", + "Fig 4-4c MO = 229.3 N.m(clockwise)\n", + "Fig 4-4d MO = 42.4 N.m(anti clockwise)\n", + "Fig 4-4e MO = 21.0 kN.m(anti clockwise)\n" + ] + } + ], + "source": [ + "# Ex 4.1\n", + "import math\n", + "\n", + "# Calculation Fig 4-4a\n", + "MO = 100*2 #[Newton meter]\n", + "\n", + "# Result Fig 4-4a\n", + "print\"Fig 4-4a MO = \",(MO),\"N.m(clockwise)\"\n", + "\n", + "# Calculation Fig 4-4b\n", + "MO = 50*0.75 #[Newton meter]\n", + "\n", + "# Result Fig 4-4b\n", + "print\"Fig 4-4b MO = \",(MO),\"N.m(clockwise)\"\n", + "\n", + "# Calculation Fig 4-4c\n", + "MO = round(40*(4+2*math.cos(math.pi*30/180)),1) #[Newton meter]\n", + "\n", + "# Result Fig 4-4b\n", + "print\"Fig 4-4c MO = \",(MO),\"N.m(clockwise)\"\n", + "\n", + "# Calculation Fig 4-4d\n", + "MO = round(60*1*math.sin(math.pi*45/180),1) #[Newton meter]\n", + "\n", + "# Result Fig 4-4d\n", + "print\"Fig 4-4d MO = \",(MO),\"N.m(anti clockwise)\"\n", + "\n", + "# Calculation Fig 4-4e\n", + "MO = round(7*(4-1),1) #[Newton meter]\n", + "\n", + "# Result Fig 4-4e\n", + "print\"Fig 4-4e MO = \",(MO),\"kN.m(anti clockwise)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.2 Page No 99" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MA = 2000.0 N.m(clockwise)\n", + "MB = 1200.0 N.m(clockwise)\n", + "MC = 0\n", + "MD = 400.0 N.m(anti clockwise)\n" + ] + } + ], + "source": [ + "# Example 4.2\n", + "\n", + "# Variable Declaration\n", + "F = 800 #[Newton]\n", + "\n", + "# Calculation\n", + "MA = F*2.5 #[Newton meter]\n", + "MB = F*1.5 #[Newton meter]\n", + "MC = F*0 #[Newton meter]\n", + "MD = F*0.5 #[Newton meter]\n", + "\n", + "# Result\n", + "print\"MA = \",(MA),\"N.m(clockwise)\"\n", + "print\"MB = \",(MB),\"N.m(clockwise)\"\n", + "print\"MC = \",(MC)\n", + "print\"MD = \",(MD),\"N.m(anti clockwise)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.3 Page No 99" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MRO = -334.0 N.m = 334.0 N.m(clockwise)\n" + ] + } + ], + "source": [ + "# Ex 4.3\n", + "import math\n", + "\n", + "# Calculation\n", + "# Assuming positive moments act in +k direction i.e counterclockwise\n", + "# +MRO(counterclockwise) = ΣFd\n", + "MRO = round(-50*(2)+60*(0)+20*(3*math.sin(30*math.pi/180))-40*(4+3*math.cos(30*math.pi/180)),0) #[Newton meter]\n", + "\n", + "# Result\n", + "print\"MRO = \",(MRO),\"N.m = \",(abs(MRO)),\"N.m(clockwise)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.4 Page No 106" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MA = 224.0 N.m\n" + ] + } + ], + "source": [ + "# Ex 4.4\n", + "import math\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "F = 60 #[Newton]\n", + "B_x = 1 #[meter]\n", + "B_y = 3 #[meter]\n", + "B_z = 2 #[meter]\n", + "C_x = 3 #[meter]\n", + "C_y = 4 #[meter]\n", + "C_z = 0 #[meter]\n", + "\n", + "# Calculation\n", + "rB_x = B_x #[meter]\n", + "rB_y = B_y #[meter]\n", + "rB_z = B_z #[meter]\n", + "F_x = round(F*((C_x-B_x)/math.sqrt((C_x-B_x)**(2)+(C_y-B_y)**(2)+(C_z-B_z)**(2))),1) #[Newton]\n", + "F_y = round(F*((C_y-B_y)/math.sqrt((C_x-B_x)**(2)+(C_y-B_y)**(2)+(C_z-B_z)**(2))),1) #[Newton]\n", + "F_z = round(F*((C_z-B_z)/math.sqrt((C_x-B_x)**(2)+(C_y-B_y)**(2)+(C_z-B_z)**(2))),1) #[Newton]\n", + "\n", + "# Let a = rB X F\n", + "a = np.cross([rB_x,rB_y,rB_z],[F_x,F_y,F_z])\n", + "MA_x = a[0] #[Newton meter]\n", + "MA_y = a[1] #[Newton meter]\n", + "MA_z = a[2] #[Newton meter]\n", + "MA = round(math.sqrt(MA_x**(2)+MA_y**(2)+MA_z**(2)),0) #[Newton meter]\n", + "\n", + "# Result\n", + "print\"MA = \",(MA),\"N.m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 4.5 Page No 107" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MRO_x = 30 N.m\n", + "MRO_y = -40 N.m\n", + "MRO_z = 60 N.m\n", + "alpha = 67.4 degrees\n", + "beta = 120.8 degrees\n", + "gamma = 39.8 degrees\n" + ] + } + ], + "source": [ + "# Example 4.5\n", + "import math\n", + "from __future__ import division\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "F1_x = -60 #[Newton]\n", + "F1_y = 40 #[Newton]\n", + "F1_z = 20 #[Newton]\n", + "F2_x = 0 #[Newton]\n", + "F2_y = 50 #[Newton]\n", + "F2_z = 0 #[Newton]\n", + "F3_x = 80 #[Newton]\n", + "F3_y = 40 #[Newton]\n", + "F3_z = -30 #[Newton]\n", + "rA_x = 0 #[meter]\n", + "rA_y = 5 #[meter]\n", + "rA_z = 0 #[meter]\n", + "rB_x = 4 #[meter]\n", + "rB_y = 5 #[meter]\n", + "rB_z = -2 #[meter]\n", + "\n", + "# Calculation\n", + "# Let MRO be resultant moment about O\n", + "# Let a = rA X F1, b = rA X F2, c = rB X F3\n", + "a = np.cross([rA_x,rA_y,rA_z],[F1_x,F1_y,F1_z])\n", + "b = np.cross([rA_x,rA_y,rA_z],[F2_x,F2_y,F2_z])\n", + "c = np.cross([rB_x,rB_y,rB_z],[F3_x,F3_y,F3_z])\n", + "MRO_x = a[0]+b[0]+c[0] #[Newton meter]\n", + "MRO_y = a[1]+b[1]+c[1] #[Newton meter]\n", + "MRO_z = a[2]+b[2]+c[2] #[Newton meter]\n", + "MRO = round(math.sqrt(MRO_x**(2)+MRO_y**(2)+MRO_z**(2)),2) #[Newton meter]\n", + "\n", + "# Let u be unit vector which defines the direction of moment axis\n", + "u_x = MRO_x/MRO\n", + "u_y = MRO_y/MRO\n", + "u_z = MRO_z/MRO\n", + "\n", + "# Let alpha,beta and gamma be coordinate direction angles of moment axis \n", + "alpha = round(math.degrees(math.acos(u_x)),1) #[degrees]\n", + "beta = round(math.degrees(math.acos(u_y)),1) #[degrees]\n", + "gamma = round(math.degrees(math.acos(u_z)),1) #[degrees]\n", + "\n", + "# Result\n", + "print\"MRO_x = \",(MRO_x),\"N.m\"\n", + "print\"MRO_y = \",(MRO_y),\"N.m\"\n", + "print\"MRO_z = \",(MRO_z),\"N.m\"\n", + "print\"alpha = \",(alpha),\"degrees\"\n", + "print\"beta = \",(beta),\"degrees\"\n", + "print\"gamma = \",(gamma),\"degrees\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.6 Page No 109" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "MA_x = 0 N.m\n", + "MA_y = 0 N.m\n", + "MA_z = 14.1 N.m\n", + "\n", + "Solution 2\n", + "MA_x = 0 N.m\n", + "MA_y = 0 N.m\n", + "MA_z = 14.1 N.m\n" + ] + } + ], + "source": [ + "# Ex 4.6\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "F = 200 #[Newton]\n", + "\n", + "# Calculation Solution 1\n", + "# Moment arm d can be found by trigonometry Refer Fig 4-19b\n", + "d = (100*math.cos(math.pi*45/180))/1000 #[meter]\n", + "# MA = Fd\n", + "MA = round(F*d,1) #[Newton meter]\n", + "\n", + "# Result Solution 1\n", + "# According to right hand thumb rule MA is directed in +k direction\n", + "print\"Solution 1\"\n", + "print\"MA_x = 0 N.m\"\n", + "print\"MA_y = 0 N.m\"\n", + "print\"MA_z = \",(MA),\"N.m\\n\"\n", + "\n", + "# Calculation Solution 2\n", + "# F is resolved into x and y components Refer Fig 4-19c\n", + "# MA = ΣFd\n", + "MA = round(F*math.sin(math.pi*45/180)*(0.20)-200*math.cos(math.pi*45/180)*(0.10),1) #[Newton meter]\n", + "\n", + "# Result Solution 2\n", + "# According to right hand thumb rule MA is directed in +k direction\n", + "print\"Solution 2\"\n", + "print\"MA_x = 0 N.m\"\n", + "print\"MA_y = 0 N.m\"\n", + "print\"MA_z = \",(MA),\"N.m\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.7 Page No 110" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1(Scalar Analysis)\n", + "MO_x = 0 N.m\n", + "MO_y = 0 N.m\n", + "MO_z = -98.6 N.m\n", + "\n", + "Solution 2(Vector Analysis)\n", + "MO_x = 0.0 N.m\n", + "MO_y = -0.0 N.m\n", + "MO_z = -98.56 N.m\n", + "\n" + ] + } + ], + "source": [ + "# Example 4.7\n", + "import math\n", + "import numpy as np \n", + "\n", + "# Variable Declaration\n", + "F = 400 #[Newton]\n", + "\n", + "# Calculation(Scalar Analysis)\n", + "# F is resolved into x and y components Refer 4-20b\n", + "# Taking +ve moments about O in +k direction\n", + "MO = round(F*math.sin(math.pi*30/180)*(0.2)-F*math.cos(math.pi*30/180)*(0.4),1) #[Newton meter]\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1(Scalar Analysis)\"\n", + "print\"MO_x = 0 N.m\"\n", + "print\"MO_y = 0 N.m\"\n", + "print\"MO_z = \",(MO),\"N.m\\n\"\n", + "\n", + "# Calculation(Vector Analysis)\n", + "# let r be positon vector and F be force vector\n", + "r_x = 0.4 #[meter]\n", + "r_y = -0.2 #[meter]\n", + "r_z = 0 #[meter]\n", + "F_x = round(F*math.sin(math.pi*30/180),1) #[Newton]\n", + "F_y = round(-F*math.cos(math.pi*30/180),1) #[Newton]\n", + "F_z = 0 #[Newton]\n", + "\n", + "# Let MO be the moment given by MO = r X F\n", + "a = np.cross([r_x,r_y,r_z],[F_x,F_y,F_z])\n", + "MO_x = a[0] #[Newton meter]\n", + "MO_y = a[1] #[Newton meter]\n", + "MO_z= a[2] #[Newton meter]\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2(Vector Analysis)\"\n", + "print\"MO_x = \",(MO_x),\"N.m\"\n", + "print\"MO_y = \",(-MO_y),\"N.m\"\n", + "print\"MO_z = \",(MO_z),\"N.m\\n\"\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.8 Page No 118" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1(Vector Analysis)\n", + "Mx = -80 N.m\n", + "Ma = -120.0 N.m\n", + "\n", + "Solution 2(Scalar Analysis)\n", + "Mx = -80 N.m\n" + ] + } + ], + "source": [ + "# Example 4.8\n", + "import math\n", + "from __future__ import division\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "F_x = -40 #[Newton]\n", + "F_y = 20 #[Newton]\n", + "F_z = 10 #[Newton]\n", + "rA_x = -3 #[meter]\n", + "rA_y = 4 #[meter]\n", + "rA_z = 6 #[meter]\n", + "ua_x = -3/5\n", + "ua_y = 4/5\n", + "ua_z = 0\n", + "\n", + "# Calculation Solution 1(Vector Analysis)\n", + "# Mx = i.(rA X F)\n", + "Mx = np.dot([1,0,0],np.cross([rA_x,rA_y,rA_z],[F_x,F_y,F_z])) #[Newton meter]\n", + "# Ma = ua.(rA X F)\n", + "Ma = np.dot([ua_x,ua_y,ua_z],np.cross([rA_x,rA_y,rA_z],[F_x,F_y,F_z])) #[Newton meter]\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1(Vector Analysis)\"\n", + "print\"Mx = \",(Mx),\"N.m\"\n", + "print\"Ma = \",(Ma),\"N.m\\n\"\n", + "\n", + "# Calculation Solution 2(Scalar Analysis)\n", + "# Refer Fig 4-23c\n", + "Mx = 10*4 - 20*6 #[Newton meter]\n", + "My = 10*3 - 40*6 #[Newton meter]\n", + "Mz = 40*4 - 20*3 #[Newton meter]\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2(Scalar Analysis)\"\n", + "print\"Mx = \",(Mx),\"N.m\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.9 Page No 119" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAB_x = -48.0 N.m\n", + "MAB_y = -24.0 N.m\n" + ] + } + ], + "source": [ + "# Example 4.9\n", + "import math\n", + "from __future__ import division\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "F_x = -600 #[Newton]\n", + "F_y = 200 #[Newton]\n", + "F_z = -300 #[Newton]\n", + "rD_x = 0 #[meter]\n", + "rD_y = 0.2 #[meter]\n", + "rD_z = 0 #[meter]\n", + "\n", + "# Calculation\n", + "# Unit vector uB defines the direction of AB axis of the rod\n", + "uB_x = 0.4/math.sqrt(0.4**(2)+0.2**(2))\n", + "uB_y = 0.2/math.sqrt(0.4**(2)+0.2**(2)) \n", + "uB_z = 0\n", + "# MAB = uB.(rD X F)\n", + "MAB = np.dot([uB_x,uB_y,uB_z],np.cross([rD_x,rD_y,rD_z],[F_x,F_y,F_z])) #[Newton meter]\n", + "MAB_x = MAB*uB_x #[Newton meter]\n", + "MAB_y = MAB*uB_y #[Newton meter]\n", + "\n", + "# Result\n", + "print\"MAB_x = \",(MAB_x),\"N.m\"\n", + "print\"MAB_y = \",(MAB_y),\"N.m\"\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 4.10 Page No 123" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F = 120.0 N\n" + ] + } + ], + "source": [ + "# Example 4.10\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Let the couple has magnitude of M having direction out of page\n", + "M = 40*0.6 #[Newton meter]\n", + "# To preserve counterclockwise rotation of M vertical forces acting through points A and B must be directed as shown in Fig 4-29c\n", + "F = M/0.2 #[Newton]\n", + "\n", + "# Result\n", + "print\"F = \",(F),\"N\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.11 Page No 124" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Moment calculated about D\n", + "MD = 195.0 N.m(counterclockwise)\n", + "Moment calculated about A\n", + "MA = 195.0 N.m(counterclockwise)\n" + ] + } + ], + "source": [ + "# Example 4.11\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "F = 150 #[Newton]\n", + "\n", + "# Calculation\n", + "F_x = (4/5)*F #[Newton]\n", + "F_y = (3/5)*F #[Newton]\n", + "\n", + "# Let the couple moment is calculated about D\n", + "MD = F_x*0 - F_y*1 + F_y*2.5 + F_x*0.5 #[Newton meter]\n", + "\n", + "# Let the couple moment is calculated about A\n", + "MA = F_y*1.5 + F_x*0.5 #[Newton meter]\n", + "\n", + "# Result\n", + "print\"Moment calculated about D\"\n", + "print\"MD = \",(MD),\"N.m(counterclockwise)\"\n", + "print\"Moment calculated about A\"\n", + "print\"MA = \",(MA),\"N.m(counterclockwise)\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.12 Page No 125" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1 (Vector Analysis)\n", + "MO_x = 0.0 N.m\n", + "MO_y = -13.0 N.m\n", + "MO_z = 0.0 N.m\n", + "MA_x = 0.0 N.m\n", + "MA_y = -13.0 N.m\n", + "MA_z = 0.0 N.m\n", + "\n", + "Solution 2 (Scalar Analysis)\n", + "M_x = 0 N.m\n", + "M_y = -13.0 N.m\n", + "M_z = 0 N.m\n" + ] + } + ], + "source": [ + "# Example 4.12\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "rA_x = 0 #[meter]\n", + "rA_y = 0.8 #[meter]\n", + "rA_z = 0 #[meter]\n", + "rB_x = 0.6*math.cos(math.pi*30/180) #[meter]\n", + "rB_y = 0.8 #[meter]\n", + "rB_z = -0.6*math.sin(math.pi*30/180) #[meter]\n", + "rAB_x = 0.6*math.cos(math.pi*30/180) #[meter]\n", + "rAB_y = 0 #[meter]\n", + "rAB_z = -0.6*math.sin(math.pi*30/180) #[meter]\n", + "# Let force acting at B be FB\n", + "FB_x = 0 #[Newton]\n", + "FB_y = 0 #[Newton]\n", + "FB_z = -25 #[Newton]\n", + "# Let force acting at A be FA\n", + "FA_x = 0 #[Newton]\n", + "FA_y = 0 #[Newton]\n", + "FA_z = 25 #[Newton]\n", + "\n", + "# Calculation Solution 1(Vector Analysis)\n", + "# Let MO be moment about about O Refer Fig 4-31b\n", + "# Let a = rA X FB, b = rB X FA\n", + "a = np.cross([rA_x,rA_y,rA_z],[FB_x,FB_y,FB_z])\n", + "b = np.cross([rB_x,rB_y,rB_z],[FA_x,FA_y,FA_z])\n", + "MO_x = round(a[0]+b[0],1) #[Newton meter]\n", + "MO_y = round(a[1]+b[1],1) #[Newton meter]\n", + "MO_z = round(a[2]+b[2],1) #[Newton meter]\n", + "\n", + "# Let MA be moment about about A Refer Fig 4-31c\n", + "# MA = rAB X FA\n", + "a = np.cross([rAB_x,rAB_y,rAB_z],[FA_x,FA_y,FA_z])\n", + "MA_x = round(a[0],1) #[Newton meter]\n", + "MA_y = round(a[1],1) #[Newton meter]\n", + "MA_z = round(a[2],1) #[Newton meter]\n", + "\n", + "# Calculation Solution 2(Vector Analysis)\n", + "M = 25*0.52 #[Newton meter]\n", + "# M acts in -j direction\n", + "M_x = 0 #[Newton meter]\n", + "M_y = -M #[Newton meter]\n", + "M_z = 0 #[Newton meter]\n", + "\n", + "# Result \n", + "print\"Solution 1 (Vector Analysis)\"\n", + "print\"MO_x = \",(MO_x),\"N.m\"\n", + "print\"MO_y = \",(MO_y),\"N.m\"\n", + "print\"MO_z = \",(MO_z),\"N.m\"\n", + "print\"MA_x = \",(MA_x),\"N.m\"\n", + "print\"MA_y = \",(MA_y),\"N.m\"\n", + "print\"MA_z = \",(MA_z),\"N.m\\n\"\n", + "print\"Solution 2 (Scalar Analysis)\"\n", + "print\"M_x = \",(M_x),\"N.m\"\n", + "print\"M_y = \",(M_y),\"N.m\"\n", + "print\"M_z = \",(M_z),\"N.m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.13 Page No 126" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MR_x = 60.0 N.m\n", + "MR_y = 22.5 N.m\n", + "MR_z= 30.0 N.m\n" + ] + } + ], + "source": [ + "# Example 4.13\n", + "from __future__ import division\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "rDC_x = 0.3 #[meter]\n", + "rDC_y = 0 #[meter]\n", + "rDC_z = 0 #[meter]\n", + "FC_x = 0 #[Newton]\n", + "FC_y = 125*(4/5) #[Newton]\n", + "FC_z = -125*(3/5) #[Newton]\n", + "\n", + "# Calculation\n", + "M1 = 150*0.4 #[Newton meter]\n", + "\n", + "# By right hand rule M1 acts in +i direction\n", + "M1_x = M1 #[Newton meter]\n", + "M1_y = 0 #[Newton meter]\n", + "M1_z = 0 #[Newton meter]\n", + "\n", + "# M2 = rDC X FC\n", + "a = np.cross([rDC_x,rDC_y,rDC_z],[FC_x,FC_y,FC_z]) \n", + "M2_x = a[0] #[Newton meter]\n", + "M2_y = a[1] #[Newton meter]\n", + "M2_z = a[2] #[Newton meter]\n", + "\n", + "# M1 and M2 are free vectors.So they may be moved to some arbitrary point P and added vectorially.\n", + "# The resultant couple moment becomes MR = M1 + M2\n", + "MR_x = M1_x + M2_x #[Newton meter]\n", + "MR_y = M1_y + M2_y #[Newton meter]\n", + "MR_z = M1_z + M2_z #[Newton meter]\n", + "\n", + "# Result\n", + "print\"MR_x = \",(MR_x),\"N.m\"\n", + "print\"MR_y = \",(MR_y),\"N.m\"\n", + "print\"MR_z= \",(MR_z),\"N.m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.14 Page No 133" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FR = 962.3 N\n", + "theta = 66.6 degrees\n", + "MRA = -551.1 N.m = 551.1 N.m(clockwise)\n" + ] + } + ], + "source": [ + "# Example 4.14\n", + "import math \n", + "\n", + "# Calculation\n", + "# Let resultant force be FR\n", + "FR_x = -100-400*math.cos(math.pi*45/180) #[Newton]\n", + "FR_y = -600-400*math.sin(math.pi*45/180) #[Newton]\n", + "FR = round(math.sqrt(FR_x**(2)+FR_y**(2)),1) #[Newton]\n", + "theta = round(math.degrees(math.atan(FR_y/FR_x)),1) #[degrees]\n", + "\n", + "# Let resultant couple moment be MRA which is calculated by summing moments of forces about A\n", + "MRA = round(100*0-600*0.4-400*math.sin(math.pi*45/180)*0.8-400*math.cos(math.pi*45/180)*0.3,1) #[Newton meter]\n", + "\n", + "# Result\n", + "print\"FR = \",(FR),\"N\"\n", + "print\"theta = \",(theta),\"degrees\"\n", + "print\"MRA = \",(MRA),\"N.m = \",(-MRA),\"N.m(clockwise)\"\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.15 Page No 134" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Example 4.15\n", + "import math\n", + "from __future__ import division\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "F1_x = 0 #[Newton]\n", + "F1_y = 0 #[Newton]\n", + "F1_z = -800 #[Newton]\n", + "F2 = 300 #[Newton]\n", + "rCB_x = -0.15 #[meter]\n", + "rCB_y = 0.1 #[meter]\n", + "rCB_z = 0 #[meter]\n", + "rC_x = 0 #[meter]\n", + "rC_y = 0 #[meter]\n", + "rC_z = 1 #[meter]\n", + "rB_x = -0.15 #[meter]\n", + "rB_y = 0.1 #[meter]\n", + "rB_z = 1 #[meter]\n", + "# Calculation\n", + "# Let uCB be unit vector along rCB\n", + "uCB_x = rCB_x/math.sqrt(rCB_x**(2)+rCB_y**(2)+rCB_z**(2))\n", + "uCB_y = rCB_y/math.sqrt(rCB_x**(2)+rCB_y**(2)+rCB_z**(2))\n", + "uCB_z = rCB_z/math.sqrt(rCB_x**(2)+rCB_y**(2)+rCB_z**(2))\n", + "F2_x = round(300*uCB_x,1) #[Newton]\n", + "F2_y = round(300*uCB_y,1) #[Newton]\n", + "F2_z = round(300*uCB_z,1) #[Newton]\n", + "M_x = 0 #[Newton meter]\n", + "M_y = -500*(4/5) #[Newton meter]\n", + "M_z = 500*(3/5) #[Newton meter]\n", + "# FR = F1 + F2\n", + "FR_x = F1_x + F2_x #[Newton]\n", + "FR_y = F1_y + F2_y #[Newton]\n", + "FR_z = F1_z + F2_z #[Newton]\n", + "\n", + "# MRO = M + rC X F1 + rB X F2\n", + "# Let a = rC X F1 and b = rB X F2\n", + "a = np.cross([rC_x,rC_y,rC_z], [F1_x,F1_y,F1_z])\n", + "b = np.cross([rB_x,rB_y,rB_z], [F2_x,F2_y,F2_z])\n", + "MRO_x = M_x + a[0] + b[0] #[Newton meter]\n", + "MRO_y = M_y + a[1] + b[1] #[Newton meter]\n", + "MRO_z = M_z + a[2] + b[2] #[Newton meter]\n", + "\n", + "# Result\n", + "print\"FR_x = \",(FR_x),\"N\"\n", + "print\"FR_y = \",(FR_y),\"N\"\n", + "print\"FR_z = \",(FR_z),\"N\"\n", + "print\"MRO_x = \",(MRO_x),\"N\"\n", + "print\"MRO_y = \",(MRO_y),\"N\"\n", + "print\"MRO_z = \",(MRO_z),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.16 Page No 139" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FR = 420.5 N\n", + "theta = 33.7 degrees\n", + "d = 3.57 m\n" + ] + } + ], + "source": [ + "# Example 4.16\n", + "import math\n", + "from __future__ import division\n", + "# Calculation\n", + "FR_x = 500*math.cos(math.pi*60/180)+100 #[Newton]\n", + "FR_y = -500*math.sin(math.pi*60/180)+200 #[Newton]\n", + "FR = round(math.sqrt(FR_x**(2)+FR_y**(2)),1) #[Newton]\n", + "theta = round(math.degrees(math.atan(FR_y/FR_x)),1) #[degrees]\n", + "\n", + "# +MRE(counterclockwise) = ΣME\n", + "d = round((500*math.sin(math.pi*60/180)*(4) + 500*math.cos(math.pi*60/180)*(0) - 100*0.5 - 200*2.5 - 350)/233.0,2) #[meter] \n", + "\n", + "# Result\n", + "print\"FR = \",(FR),\"N\"\n", + "print\"theta = \",(-theta),\"degrees\"\n", + "print\"d = \",(d),\"m\" # Correction in the answer" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 4.17 Page No 140" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y = 1.146 m\n", + "x = 5.442 m\n" + ] + } + ], + "source": [ + "# Example 4.17\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Let FR be resultant force\n", + "FR_x = -250*(3/5)-175 #[Newton]\n", + "FR_y = -250*(4/5)-60 #[Newton]\n", + "FR = round(math.sqrt(FR_x**(2)+FR_y**(2)),1) #[Newton]\n", + "theta = round(math.degrees(math.atan(FR_y/FR_x)),1) #[degrees]\n", + "\n", + "# +MRA(counterclockwise) = ΣMA\n", + "y = round((175*2.5 - 60*1.5 + 250*(3/5)*5.5 - 250*(4/5)*4 - 260*(0))/325,3) #[meter]\n", + "\n", + "# By principle of transmissibility FR can be treated as intersecting BC Refer Fig 4-44b\n", + "# +MRA(counterclockwise) = ΣMA\n", + "x = round((325*5.5 - 175*2.5 + 60*1.5 - 250*(3/5)*5.5 + 250*(4/5)*4)/260,3) #[meter]\n", + "\n", + "# Result\n", + "print\"y = \",(y),\"m\"\n", + "print\"x = \",(x),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 4.18 Page No 141" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y = 2.5 m\n", + "x = 3.0 m\n" + ] + } + ], + "source": [ + "# Example 4.18\n", + "\n", + "# Calculation\n", + "# +FR = ΣF Refer Fig 4-45a\n", + "FR = -600+100-400-500 #[Newton]\n", + "# Using right hand thumb rule where ppsitive moments act in +i direction we have MR_x = ΣM_x\n", + "y = round(-(600*(0)+100*5-400*10+500*0)/1400,2) #[meter]\n", + "# Assuming positive moments act in +j direction\n", + "# MR_y = ΣM_y\n", + "x = round((600*8-100*6+400*0+500*0)/1400,2) #[meter]\n", + "\n", + "# Result\n", + "print\"y = \",(y),\"m\"\n", + "print\"x = \",(x),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.19 Page No 142" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FR_x = 0 N\n", + "FR_y = 0 N\n", + "FR_z = -650 N\n", + "x = 0.6 m\n", + "y = -0.29 m\n" + ] + } + ], + "source": [ + "# Example 4.19\n", + "import math\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "FR_x = 0 #[Newton]\n", + "FR_y = 0 #[Newton]\n", + "FR_z = -300-200-150 #[Newton]\n", + "rA_x = 2 #[meter]\n", + "rA_y = 0 #[meter]\n", + "rA_z = 0 #[meter] \n", + "rB_x = 0 #[meter]\n", + "rB_y = -2 #[meter]\n", + "rB_z = 0 #[meter]\n", + "rC_x = -2*math.sin(math.pi*45/180) #[meter] \n", + "rC_y = 2*math.cos(math.pi*45/180) #[meter]\n", + "rC_z = 0 #[meter]\n", + "\n", + "# Let a = rA X (-300k), b = rB X (-200k), c = rC X (-150k)\n", + "a = np.cross([rA_x,rA_y,rA_z], [0,0,-300])\n", + "b = np.cross([rB_x,rB_y,rB_z], [0,0,-200])\n", + "c = np.cross([rC_x,rC_y,rC_z], [0,0,-150])\n", + "x = round((a[1]+b[1]+c[1])/650,2) #[meter]\n", + "y = round(-((a[0]+b[0]+c[0]))/650,2) #[meter]\n", + "\n", + "# Result\n", + "print\"FR_x = \",(FR_x),\"N\"\n", + "print\"FR_y = \",(FR_y),\"N\"\n", + "print\"FR_z = \",(FR_z),\"N\"\n", + "print\"x = \",(x),\"m\"\n", + "print\"y = \",(y),\"m\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 4.20 Page No 148" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FR = 160.0 N\n", + "x_bar = 1.5 m\n" + ] + } + ], + "source": [ + "# Example 4.20\n", + "from scipy import integrate\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# The coloured differential area element dA = wdx = 60x**(2)\n", + "# Summing these elements from x = 0 to x = 2m we obtain force FR\n", + "# FR = ΣF\n", + "var = lambda x: 60*x**(2)\n", + "a = integrate.quad(var, 0, 2)\n", + "FR = a[0] #[Newton]\n", + "\n", + "# Since the element of area dA is located at distance x from O, the location x_bar of FR is measured from O\n", + "var = lambda x: x*60*x**(2)\n", + "a = integrate.quad(var, 0, 2)\n", + "x_bar = a[0]/FR #[meter]\n", + "\n", + "# Result\n", + "print\"FR = \",(FR),\"N\"\n", + "print\"x_bar = \",(x_bar),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.21 Page No 149" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FR = 6.48 kN\n", + "x_bar = 6.0 m\n" + ] + } + ], + "source": [ + "# Example 4.21\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# The magnitude of resultant force is equal to the area under the triangle\n", + "FR = (0.5*9*1440)/1000 #[Newton]\n", + "\n", + "# The line of action of FR passes through the centroid C of the triangle\n", + "x_bar = 9-(1/3)*9 #[meter]\n", + "\n", + "# Result\n", + "print\"FR = \",(FR),\"kN\"\n", + "print\"x_bar =\",(x_bar),\"m\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 4.22 Page No 150" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FR = 225.0 N\n", + "x_bar = 1.33333333333 m\n" + ] + } + ], + "source": [ + "# Example 4.22\n", + "\n", + "# Calculation\n", + "# Refer Fig 4-50b\n", + "# The magnitude of the force represented by each of these loadings is equal to its associated area\n", + "F1 = 0.5*3*50 #[Newton]\n", + "F2 = 3*50 #[Newton]\n", + "\n", + "# The lines of action of these parallel forces act through the centroid of their associated areas\n", + "x1_bar = (1/3)*3 #[meter]\n", + "x2_bar = (1/2)*3 #[meter]\n", + "\n", + "# +FR(downward) = ΣF\n", + "FR = F1 + F2 #[Newton]\n", + "\n", + "# +MRA(clockwise) = ΣMA\n", + "x_bar = (1*75+1.5*150)/225 #[meter]\n", + "\n", + "# Result\n", + "print\"FR = \",(FR),\"N\"\n", + "print\"x_bar = \",(x_bar),\"m\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_5_Equilibrium_of_a_Rigid_Body.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_5_Equilibrium_of_a_Rigid_Body.ipynb new file mode 100644 index 00000000..b3b5669a --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_5_Equilibrium_of_a_Rigid_Body.ipynb @@ -0,0 +1,561 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 5 Equilibrium of a Rigid Body" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.6 Page No 174 " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "B_x = 424.3 N\n", + "A_y = 319.5 N\n", + "B_y = 405.3 N\n" + ] + } + ], + "source": [ + "# Example 5.6\n", + "import math\n", + "\n", + "# Calculation\n", + "# Summing forces in the x direction +ΣF_x(right) = 0\n", + "B_x = round(600*math.cos(math.pi*45/180),1) #[Newton]\n", + "\n", + "# Refer Fig 5-14b we have +ΣMB(counterclockwise) = 0\n", + "A_y = round((100*2+600*math.sin(math.pi*45/180)*5-600*math.cos(math.pi*45/180)*0.2)/7,1) #[Newton]\n", + "\n", + "# Summing forces in y direction +ΣF_y(upward) = 0\n", + "B_y = round(-319+600*math.sin(math.pi*45/180)+100+200,1) #[Newton]\n", + "\n", + "# Result\n", + "print\"B_x = \",(B_x),\"N\"\n", + "print\"A_y = \",(A_y),\"N\"\n", + "print\"B_y = \",(B_y),\"N\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.7 Page No 175" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T = 100.0 N\n", + "A_x = 50.0 N\n", + "A_y = 186.6 N\n" + ] + } + ], + "source": [ + "# Example 5.7\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "F = 100 #[Newton]\n", + "\n", + "# Calculation\n", + "# Summing moments about point A to eliminate A_x and A_y Refer Fig 5-15c\n", + "# +ΣMA(counterclockwise) = 0\n", + "T = round((F*0.5)/0.5,1) #[Newton]\n", + "\n", + "# Using result of T a force summation is applied to determine the components of reaction at pin A\n", + "# +ΣF_x(right) = 0\n", + "A_x = round(F*math.sin(math.pi*30/180),1) #[Newton]\n", + "\n", + "# +ΣF_y(upward) = 0\n", + "A_y = round(F+F*math.cos(math.pi*30/180),1) #[Newton]\n", + " \n", + "# Result\n", + "print\"T = \",(T),\"N\"\n", + "print\"A_x = \",(A_x),\"N\"\n", + "print\"A_y = \",(A_y),\"N\"\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.8 Page No 176" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A_x = 100.0 N\n", + "A_y = 233.2 N\n" + ] + } + ], + "source": [ + "# Example 5.8\n", + "import math\n", + "\n", + "# Calculation\n", + "# Summing moments about A, we obtain direct solution for NB\n", + "# +ΣMA(counterclockwise) = 0\n", + "NB = (90+60)/0.75 #[Newton]\n", + "\n", + "# +ΣF_x(right) = 0\n", + "A_x = round(NB*math.sin(math.pi*30/180),1) #[Newton]\n", + "\n", + "# +ΣF_y(upward) = 0\n", + "A_y = round(NB*math.cos(math.pi*30/180)+60,1) #[Newton]\n", + "\n", + "# Result\n", + "print\"A_x = \",(A_x),\"N\"\n", + "print\"A_y = \",(A_y),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.9 Page No 177" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A_x = 5.0 N\n", + "A_y = 74.0 N\n", + "MA = 32.6 N.m\n", + "FA = 74.2 N\n" + ] + } + ], + "source": [ + "# Example 5.9\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# +ΣF_x(right) = 0\n", + "A_x = round(52*(5/13)-30*math.cos(math.pi*60/180),1) #[Newton]\n", + "# +ΣF_y(upward) = 0\n", + "A_y = round(52*(12/13)+30*math.sin(math.pi*60/180),1) #[Newton]\n", + "# +ΣMA(counterclockwise) = 0\n", + "MA = round(52*(12/13)*0.3+30*math.sin(math.pi*60/180)*0.7,1) #[Newton meter]\n", + "FA = round(math.sqrt(A_x**(2)+A_y**(2)),1) #[Newton]\n", + "theta = math.degrees(math.atan(A_y/A_x)) #[degrees]\n", + "\n", + "# Result\n", + "print\"A_x = \",(A_x),\"N\"\n", + "print\"A_y = \",(A_y),\"N\"\n", + "print\"MA = \",(MA),\"N.m\"\n", + "print\"FA = \",(FA),\"N\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.10 Page No 178" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C_y_dash = 1.3464 kN\n", + "B_y_dash = -1.0 kN\n", + "A_x = 173.2 Nnn\n" + ] + } + ], + "source": [ + "# Example 5.10\n", + "import math\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Refer Fig 5-18b\n", + "# Using +ΣF_y(upward) = 0 and +ΣMA(counterclockwise) = 0\n", + "a = np.array([[math.cos(math.pi*30/180),math.cos(math.pi*30/180)], [6,2]])\n", + "b = np.array([300,4000+300*math.cos(math.pi*30/180)*8])\n", + "x = np.linalg.solve(a, b)\n", + "C_y_dash = round(x[0],1) #[Newton]\n", + "B_y_dash = round(x[1],1) #[Newton]\n", + "\n", + "# Using +ΣF_x(right) = 0\n", + "A_x = round(C_y_dash*math.sin(math.pi*30/180)+B_y_dash*math.sin(math.pi*30/180),1) #[Newton]\n", + "\n", + "# Result\n", + "print\"C_y_dash = \",(C_y_dash/1000),\"kN\"\n", + "print\"B_y_dash = \",(B_y_dash/1000),\"kN\"\n", + "print\"A_x = \",(A_x),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 5.11 Page No 181" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta = 60.3 degrees\n", + "FA = 1.07 kN\n", + "F = 1.32 kN\n" + ] + } + ], + "source": [ + "# Example 5.11\n", + "import math\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Since ΣMO = 0 angle theta which defines the line of action of FA can be determined by trigonometry\n", + "theta = round(math.degrees(math.atan(0.7/0.4)),1) #[Degrees]\n", + "\n", + "# Using +ΣF_x(right) = 0 and +ΣF_y(upward) = 0\n", + "a = np.array([[math.cos(math.pi*theta/180),-math.cos(math.pi*45/180)], [math.sin(math.pi*theta/180),-math.sin(math.pi*45/180)]])\n", + "b = np.array([-400,0])\n", + "x = np.linalg.solve(a, b)\n", + "FA = round(x[0]/1000,2) #[Newton]\n", + "F = round(x[1]/1000,2) #[Newton]\n", + "\n", + "# Result\n", + "print\"theta = \",(theta),\"degrees\"\n", + "print\"FA = \",(FA),\"kN\"\n", + "print\"F = \",(F),\"kN\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.13 Page No 197" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "B_x = 0 N\n", + "B_y = 0 N\n", + "A_z = 790.5 N\n", + "B_z = -216.7 N\n", + "TC = 707.2 N\n" + ] + } + ], + "source": [ + "# Example 5.13\n", + "\n", + "# Calculation\n", + "# Using ΣF_x = 0ΣF_z = 0\n", + "B_x = 0 #[Newton]\n", + "# Using ΣF_y= 0\n", + "B_y = 0 #[Newton]\n", + "# Using ΣF_z = 0, A_z + B_z + TC = 300 + 981(1)\n", + "# Using ΣM_x = 0, 2TC + 2B_z = 981(2)\n", + "# Using ΣM_y = 0, 3B_z + 3A_z = 300(1.5) + 981(1.5) - 200(3)\n", + "# Solving (1),(2) and (3)\n", + "a = np.array([[1,1,1], [0,2,2],[3,3,0] ])\n", + "b = np.array([300+981,981,300*1.5+981*1.5-200])\n", + "x = np.linalg.solve(a, b)\n", + "A_z = round(x[0],1) #[Newton]\n", + "B_z = round(x[1],1) #[Newton]\n", + "TC = round(x[2],1) #[Newton]\n", + "\n", + "# Result\n", + "print\"B_x = \",(B_x),\"N\"\n", + "print\"B_y = \",(B_y),\"N\"\n", + "print\"A_z = \",(A_z),\"N\"\n", + "print\"B_z = \",(B_z),\"N\"\n", + "print\"TC = \",(TC),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.14 Page No 198" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P = 377.6 N\n", + "A_z = 424.3 N\n", + "B_z = 934.3 N\n" + ] + } + ], + "source": [ + "# Example 5.14\n", + "import math \n", + "\n", + "# Calculation\n", + "# Using right hand rule and assuming positive moments act in +i direction, ΣM_x = 0\n", + "P = round((981*0.1)/(0.3*math.cos(math.pi*30/180)),1) #[Newton]\n", + "\n", + "# Using this result for P and summing moments about y and z axis, ΣM_y = 0 and ΣM_z = 0\n", + "A_z = round((981*0.5-P*0.4)/0.8,1) #[Newton]\n", + "A_y = -0/0.8 #[Newton]\n", + "\n", + "# The reactions at B are determined by using ΣF_x = 0, ΣF_y = 0 and ΣF_z = 0\n", + "A_x = 0 #[Newton]\n", + "B_y = 0 #[Newton]\n", + "B_z = round(P+981-A_z,1) #[Newton]\n", + "\n", + "# Result\n", + "print\"P = \",(P),\"N\"\n", + "print\"A_z = \",(A_z),\"N\"\n", + "print\"B_z = \",(B_z),\"N\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.15 Page No 199" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TC = 707.5 N\n", + "TD = 1500.0 N\n", + "A_x = -0.0 N\n", + "A_y = 0.0 N\n", + "A_z = 1500.2 N\n" + ] + } + ], + "source": [ + "# Example 5.15\n", + "import numpy as np\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Summing moments about point A ΣMA = 0, rB X (F+TC+TD)\n", + "# Evaluating cross product\n", + "a = np.array([[0,-4], [4.24,-2]])\n", + "b = np.array([-6000,0])\n", + "x = np.linalg.solve(a, b)\n", + "TC = round(x[0],1) #[Newton]\n", + "TD = round(x[1],1) #[Newton]\n", + "\n", + "# Using ΣF_x = 0\n", + "A_x = round(-0.707*TC+(3/9)*TD,0) #[Newton]\n", + "\n", + "# Using ΣF_y = 0 \n", + "A_y = round(1000-(6/9)*TD,1) #[Newton]\n", + "\n", + "# Using ΣF_z= 0\n", + "A_z = round(0.707*TC+(6/9)*TD,1) #[Newton]\n", + " \n", + "# Result\n", + "print\"TC = \",(TC),\"N\" \n", + "print\"TD = \",(TD),\"N\" \n", + "print\"A_x = \",(A_x),\"N\" \n", + "print\"A_y = \",(A_y),\"N\" \n", + "print\"A_z = \",(A_z),\"N\" " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.16 Page No 200" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TD = 100.0 N\n", + "TE = 100.0 N\n", + "A_x = -50.0 N\n", + "A_y = -100.0 N\n", + "A_z = 200 N\n" + ] + } + ], + "source": [ + "# Example 5.16\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Summing moments about point A, ΣMA = 0 and rC X F + rB X (TE + TD) = 0\n", + "# Using ΣM_x = 0 and ΣM_y = 0\n", + "TD = 200/2 #[Newton]\n", + "TE = 100/2 #[Newton]\n", + "\n", + "# Using ΣF_x = 0, ΣF_y = 0 and ΣF_z = 0\n", + "A_x = -TE #[Newton]\n", + "A_y = -TD #[Newton]\n", + "A_z = 200 #[Newton]\n", + "\n", + "# Result\n", + "print\"TD = \",(TD),\"N\"\n", + "print\"TE = \",(TD),\"N\"\n", + "print\"A_x = \",(A_x),\"N\"\n", + "print\"A_y = \",(A_y),\"N\"\n", + "print\"A_z = \",(A_z),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 5.17 Page No 201" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TB = 572.3 N\n" + ] + } + ], + "source": [ + "# Example 5.17\n", + "\n", + "# Calculation\n", + "# Using u.(rB X TB + rE X W)\n", + "TB = round(490.5/0.857,1) #[Newton]\n", + "\n", + "print\"TB = \",(TB),\"N\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_6_Structural_Analysis.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_6_Structural_Analysis.ipynb new file mode 100644 index 00000000..4fe7e652 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_6_Structural_Analysis.ipynb @@ -0,0 +1,768 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 6 Structural Analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.1 Page No 212" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FBC = 707.1 N\n", + "FBA = 500.0 N\n", + "FCA = 500.0 N\n", + "C_y = 500.0 N\n", + "A_x = 500 N\n", + "A_y = 500 N\n" + ] + } + ], + "source": [ + "# Example 6.1\n", + "import math\n", + "\n", + "# Calculation\n", + "\n", + "# Joint B\n", + "# Using +ΣF_x(right) = 0\n", + "FBC = round(500/math.sin(math.pi*45/180),1) #[Newton]\n", + "\n", + "# Using +ΣF_y(upward) = 0\n", + "FBA = round(FBC*math.cos(math.pi*45/180),1) #[Newton]\n", + "\n", + "# Joint C\n", + "# Using +ΣF_x(right) = 0\n", + "FCA = round(FBC*math.cos(math.pi*45/180),1) #[Newton]\n", + "\n", + "# Using +ΣF_y(upward) = 0\n", + "C_y = round(FBC*math.sin(math.pi*45/180),1) #[Newton]\n", + "\n", + "# Joint A\n", + "# # Using +ΣF_x(right) = 0\n", + "A_x = 500 #[Newton]\n", + "A_y = 500 #[Newton]\n", + "\n", + "# Result\n", + "print\"FBC = \",(FBC),\"N\"\n", + "print\"FBA = \",(FBA),\"N\"\n", + "print\"FCA = \",(FCA),\"N\"\n", + "print\"C_y = \",(C_y),\"N\"\n", + "print\"A_x = \",(A_x),\"N\"\n", + "print\"A_y = \",(A_y),\"N\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.2 Page No 213" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FCB = 5.02 kN\n", + "FCD = 4.1 kN\n", + "FDA = 4.1 kN\n", + "FDB = 4.1 kN\n" + ] + } + ], + "source": [ + "# Example 6.2\n", + "import math\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "# Joint C\n", + "# Using +ΣF_x(right) = 0 and +ΣF_y(upward) = 0\n", + "a = np.array([[-math.cos(math.pi*30/180),math.sin(math.pi*45/180)],[math.sin(math.pi*30/180),-math.cos(math.pi*45/180)]])\n", + "b = np.array([0,-1.5])\n", + "x = np.linalg.solve(a, b)\n", + "FCD = round(x[0],2) #[kilo Newton]\n", + "FCB = round(x[1],2) #[kilo Newton]\n", + "\n", + "# Calculation\n", + "# Joint D\n", + "# Using +ΣF_x(right) = 0\n", + "FDA = round(FCD*math.cos(math.pi*30/180)/math.cos(math.pi*30/180),2) #[kilo Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "FDB = round(2*FCD*math.sin(math.pi*30/180),2) #[kilo Newton]\n", + "\n", + "# Result\n", + "print\"FCB = \",(FCB),\"kN\"\n", + "print\"FCD = \",(FCD),\"kN\"\n", + "print\"FDA = \",(FDA),\"kN\"\n", + "print\"FDB = \",(FDB),\"kN\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.3 Page No 214" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FAB = 750.0 N\n", + "FAD = 450.0 N\n", + "FDB = -250.0 N\n", + "FDC = 200.0 N\n", + "FCB = 600 N\n" + ] + } + ], + "source": [ + "# Example 6.3\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Using +ΣF_x(right) = 0\n", + "C_x = 600 #[Newton]\n", + "# Using +ΣMC(counterclockwise) = 0\n", + "A_y = (400*3+600*4)/6 #[Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "C_y = A_y - 400 #[Newton]\n", + "\n", + "# Joint A\n", + "# Using +ΣF_y(upward) = 0\n", + "FAB = 600*(5/4) #[Newton]\n", + "# Using +ΣF_x(right) = 0\n", + "FAD = (3/5)*FAB #[Newton]\n", + "\n", + "# Joint D\n", + "# Using +ΣF_x(right) = 0\n", + "FDB = (450-600)*(5/3) #[Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "FDC = (-4/5)*(FDB) #[Newton]\n", + "\n", + "# Joint C\n", + "# Using +ΣF_x(right) = 0\n", + "FCB = 600 #[Newton]\n", + "\n", + "# Result\n", + "print\"FAB = \",(FAB),\"N\"\n", + "print\"FAD = \",(FAD),\"N\"\n", + "print\"FDB = \",(FDB),\"N\"\n", + "print\"FDC = \",(FDC),\"N\"\n", + "print\"FCB = \",(FCB),\"N\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 6.4 Page No 218" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FGC = 0 N\n", + "FDF= 0 N\n" + ] + } + ], + "source": [ + "# Example 6.4\n", + "\n", + "# Calculation\n", + "# Using +ΣF_y(upward) = 0 at joint G\n", + "FGC = 0 #[Newton]\n", + "\n", + "# GC is a zero force menber means that 5-kN load at C must be supported by members CB,CH,CF and CD\n", + "# Using +ΣF_y(upward) = 0 at joint F\n", + "FDF = 0 #[Newton]\n", + "\n", + "# Result\n", + "print\"FGC = \",(FGC),\"N\"\n", + "print\"FDF= \",(FDF),\"N\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.5 Page No 225" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FBC = 800.0 N\n", + "FGE = 800.0 N\n", + "FGC = 500.0 N\n" + ] + } + ], + "source": [ + "# Example 6.5\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Applying equations of equilibrium\n", + "# Using +ΣF_x(right) = 0\n", + "A_x = 400 #[Newton]\n", + "\n", + "# Using +ΣMA(counterclockwise) = 0\n", + "D_y = (400*3+1200*8)/12 #[Newton]\n", + "\n", + "# Using +ΣF_y(upward) = 0\n", + "A_y = 1200-900 #[Newton]\n", + "\n", + "# Using +ΣMG(counterclockwise) = 0\n", + "FBC = (400*3+300*4)/3 #[Newton]\n", + "\n", + "# Using +ΣMC(counterclockwise) = 0\n", + "FGE = (300*8)/3 #[Newton]\n", + "\n", + "# Using +ΣF_y(upward) = 0\n", + "FGC = (300*5)/3 #[Newton]\n", + "\n", + "# Result\n", + "print\"FBC = \",(FBC),\"N\"\n", + "print\"FGE = \",(FGE),\"N\"\n", + "print\"FGC = \",(FGC),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.6 Page No 226" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FCF = 0.589 kN\n" + ] + } + ], + "source": [ + "# Example 6.6\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Using +ΣMO(counterclockwise) = 0\n", + "FCF = round((3*8-4.75*4)/(12*math.sin(math.pi*45/180)),3) #[kilo Newton]\n", + "\n", + "# Result\n", + "print\"FCF = \",(FCF),\"kN\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.7 Page No 227" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FEB = 2000.0 N\n" + ] + } + ], + "source": [ + "# Example 6.7\n", + "import math\n", + "\n", + "# Calculation\n", + "# Using +ΣMB(counterclockwise) = 0\n", + "FED = (-1000*4-3000*2+4000*4)/(math.sin(math.pi*30/180)*4) #[Newton]\n", + "\n", + "# Using +ΣF_x(right) = 0 for section bb Fig 6-18c\n", + "FEF = 3000*math.cos(math.pi*30/180)/math.cos(math.pi*30/180) #[Newton]\n", + "\n", + "# Using +ΣF_y(upward) = 0\n", + "FEB = 2*3000*math.sin(math.pi*30/180)-1000 #[Newton]\n", + "\n", + "# Result\n", + "print\"FEB = \",(FEB),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.8 Page No 231" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FAE = 0.0 kN\n", + "FAB = 4.0 kN\n", + "FAC = 0.0 kN\n", + "RB = 5.66 kN\n", + "FBE = 5.66 kN\n", + "FBD = 2.0 kN\n", + "FDE = 0 kN\n", + "FDC = 0 kN\n", + "FCE = 0 kN\n" + ] + } + ], + "source": [ + "# Example 6.8\n", + "import numpy as np\n", + "import math\n", + "\n", + "# Calculation\n", + "# At joint A, ΣF_x = 0, ΣF_y = 0, ΣF_z = 0\n", + "a = np.array([[0.577,0,0],[0.577,1,0],[-0.577,0,-1]])\n", + "b = np.array([0,4,0])\n", + "x = np.linalg.solve(a, b)\n", + "FAE = round(x[0],2) #[kilo Newton]\n", + "FAB = round(x[1],2) #[kilo Newton]\n", + "FAC = round(x[2],2) #[kilo Newton]\n", + "\n", + "# At joint B, ΣF_x = 0, ΣF_y = 0, ΣF_z = 0\n", + "a = np.array([[-math.cos(math.pi*45/180),0.707,0],[math.sin(math.pi*45/180),0,0],[0,-0.707,1]])\n", + "b = np.array([0,4,-2])\n", + "x = np.linalg.solve(a, b)\n", + "RB = round(x[0],2) #[kilo Newton]\n", + "FBE = round(x[1],2) #[kilo Newton]\n", + "FBD = round(x[2],2) #[kilo Newton]\n", + "\n", + "# The scalar equation of equilibrium can be applied at joints D and C\n", + "FDE = FDC = FCE = 0 #[kilo Newton]\n", + "\n", + "# Result\n", + "print\"FAE = \",(FAE),\"kN\"\n", + "print\"FAB = \",(FAB),\"kN\"\n", + "print\"FAC = \",(-FAC),\"kN\"\n", + "print\"RB = \",(RB),\"kN\"\n", + "print\"FBE = \",(FBE),\"kN\"\n", + "print\"FBD = \",(FBD),\"kN\"\n", + "print\"FDE = \",(FDE),\"kN\"\n", + "print\"FDC = \",(FDC),\"kN\"\n", + "print\"FCE = \",(FCE),\"kN\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.14 Page No 241" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C_x = 577.4 N\n", + "C_y = 1000.0 N\n" + ] + } + ], + "source": [ + "# Example 6.14\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "\n", + "# Solution 1\n", + "# Applying equations of equilibrium to member CB\n", + "# Using +ΣMC(counterclockwise) = 0\n", + "FAB = round((2000*2)/(math.sin(math.pi*60/180)*4),1) #[Newton meter]\n", + "# Using +ΣF_x(right) = 0\n", + "C_x = round(FAB*math.cos(math.pi*60/180),1) #[Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "C_y = round(-FAB*math.sin(math.pi*60/180)+2000,1) #[Newton]\n", + "\n", + "# Solution 2 \n", + "# Using +ΣMC(counterclockwise) = 0 at Member BC\n", + "B_y = (2000*2)/4 #[Newton]\n", + "# Using +ΣMA(counterclockwise) = 0 at Member AB\n", + "B_x = round(B_y*3*math.cos(math.pi*60/180)/(3*math.sin(math.pi*60/180)),1) #[Newton]\n", + "# Using +ΣF_y(upward) = 0 at member BC\n", + "C_x = B_x #[Newton]\n", + "C_y = 2000-B_y #[Newton]\n", + "# Result\n", + "print\"C_x = \",(C_x),\"N\"\n", + "print\"C_y = \",(C_y),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.15 Page No 242" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A_x = 6.0 kN\n", + "A_y = 12.0 kN\n", + "MA = 32.0 kN.m\n", + "B_x = 0 kN\n", + "B_y = 4.0 kN\n", + "C_y = 4.0 kN\n" + ] + } + ], + "source": [ + "# Example 6.15\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Using +ΣF_x(right) = 0 at member BC\n", + "B_x = 0 #[kilo Newton]\n", + "# Using +ΣMB(counterclockwise) = 0 at member BC\n", + "C_y = (8*1)/2 #[kilo Newton]\n", + "# Using +ΣF_y(upward) = 0 at member BC\n", + "B_y = 8-C_y #[kilo Newton]\n", + "# Using +ΣF_x(right) = 0 at member AB\n", + "A_x = 10*(3/5)-B_x #[kilo Newton]\n", + "# Using +ΣMA(counterclockwise) = 0 at member AB\n", + "MA = 10*(4/5)*2+B_y*4 #[kilo Newton meter]\n", + "# Using +ΣF_y(upward) = 0 at member AB\n", + "A_y = 10*(4/5)+B_y #[kilo Newton]\n", + "\n", + "# Result\n", + "print\"A_x = \",(A_x),\"kN\"\n", + "print\"A_y = \",(A_y),\"kN\"\n", + "print\"MA = \",(MA),\"kN.m\"\n", + "print\"B_x = \",(B_x),\"kN\"\n", + "print\"B_y = \",(B_y),\"kN\"\n", + "print\"C_y = \",(C_y),\"kN\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.16 Page No 243" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C_x = 1226.3 N\n", + "C_y = -245.3 N\n" + ] + } + ], + "source": [ + "# Example 6.16\n", + "import math\n", + "\n", + "# Calculation\n", + "# Using +ΣMA(counterclockwise) = 0\n", + "D_x = (981*2)/2.8 #[Newton]\n", + "# Using +ΣF_x(right) = 0\n", + "A_x = D_x #[Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "A_y = 981 #[Newton]\n", + "\n", + "# Consider member CEF\n", + "# Using +ΣMC(counterclockwise) = 0\n", + "FB = round((-981*2)/(math.sin(math.pi*45/180)*1.6),1) #[Newton]\n", + "# Using +ΣF_x(right) = 0\n", + "C_x = round(-FB*math.cos(math.pi*45/180),1) #[Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "C_y = round(FB*math.sin(math.pi*45/180)+981,1) #[Newton]\n", + "\n", + "# Result\n", + "print\"C_x = \",(C_x),\"N\"\n", + "print\"C_y = \",(C_y),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 6.17 Page No 243" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "B_x = 18.2 N\n", + "B_y = 20 N\n", + "D_x = 0 N\n", + "D_y = 20 N\n" + ] + } + ], + "source": [ + "# Example 6.17\n", + "\n", + "# Calculation\n", + "# Consider entire frame\n", + "# Using +ΣMA(counterclockwise) = 0\n", + "C_x = (20*1)/1.1 #[Newton]\n", + "# Using +ΣF_x(right) = 0\n", + "A_x = 18.2 #[Newton]\n", + "A_y = 20 #[Newton]\n", + "\n", + "# Consider member AB\n", + "# Using +ΣF_x(right) = 0\n", + "B_x= 18.2 #[Newton]\n", + "# Using +ΣMB(counterclockwise) = 0\n", + "ND = (20*2)/1 #[Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "B_y = 40-20 #[Newton]\n", + "\n", + "# Consider Disk\n", + "# Using +ΣF_x(right) = 0\n", + "D_x = 0 #[Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "D_y = 40-20 #[Newton]\n", + "\n", + "# Result\n", + "print\"B_x = \",(B_x),\"N\"\n", + "print\"B_y = \",(B_y),\"N\"\n", + "print\"D_x = \",(D_x),\"N\"\n", + "print\"D_y = \",(D_y),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.18 Page No 245" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P = 200 N\n", + "T = 400 N\n", + "R = 800 N\n" + ] + } + ], + "source": [ + "# Example 6.18\n", + "\n", + "# Calculation\n", + "# Using equations of equilibrium\n", + "\n", + "# Pulley A\n", + "# Using +ΣF_y(upward) = 0\n", + "P = 600/3 #[Newton]\n", + "\n", + "# Pulley B\n", + "# Using +ΣF_y(upward) = 0\n", + "T = 2*P #[Newton]\n", + "\n", + "# Pulley C\n", + "# Using +ΣF_y(upward) = 0\n", + "R = 2*P+T #[Newton]\n", + "\n", + "# Result\n", + "print\"P = \",(P),\"N\"\n", + "print\"T = \",(T),\"N\"\n", + "print\"R = \",(R),\"N\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 6.19 Page No 246" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "B_x = 346.8 N\n", + "B_y = 837.3 N\n", + "FCB = 1659.8 N\n", + "FAB = 1342.7 N\n" + ] + } + ], + "source": [ + "# Example 6.19\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Applying equations of equilibrium to pulley B\n", + "# Using +ΣF_x(right) = 0\n", + "B_x = round(490.5*math.cos(math.pi*45/180),1) #[Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "B_y = round(490.5*math.sin(math.pi*45/180)+490.5,1) #[Newton]\n", + "\n", + "# Applying equations of equilibrium to pin\n", + "# Using +ΣF_y(upward) = 0\n", + "FCB = round((B_y+490.5)*(5/4),1) #[Newton]\n", + "# Using +ΣF_x(right) = 0\n", + "FAB = round((3/5)*FCB+B_x,1) #[Newton]\n", + "\n", + "# Result\n", + "print\"B_x = \",(B_x),\"N\"\n", + "print\"B_y = \",(B_y),\"N\"\n", + "print\"FCB = \",(FCB),\"N\"\n", + "print\"FAB = \",(FAB),\"N\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_7_Internal_Forces.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_7_Internal_Forces.ipynb new file mode 100644 index 00000000..013e54d4 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_7_Internal_Forces.ipynb @@ -0,0 +1,391 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 7 Internal Forces" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 7.1 Page no 261" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A_y = 8 kN\n", + "NC = 4 kN\n" + ] + } + ], + "source": [ + "# Example 7.1\n", + "\n", + "# Calculation\n", + "# Applying +ΣF_y(upward) = 0 Refer fig 7-4b\n", + "A_y = 16+4-12 #[kilo Newton]\n", + "\n", + "# Applying +ΣF_y(upward) = 0 to segment AB\n", + "NB = 8 #[kilo Newton]\n", + "\n", + "# Applying +ΣF_y(upward) = 0 to segment DC\n", + "NC = 4 #[kilo Newton]\n", + "\n", + "# Result\n", + "print\"A_y = \",(A_y),\"kN\"\n", + "print\"NC = \",(NC),\"kN\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 7.2 Page no 262" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TB = 5 N.m\n", + "TC = 25 N.m\n" + ] + } + ], + "source": [ + "# Example 7.2\n", + "\n", + "# Calculation\n", + "# Applying +ΣM_x = 0 Refer fig 7-5b\n", + "TD = -10+15+20 #[Newton meter]\n", + "\n", + "# Applying +ΣM_x = 0 to segment AB\n", + "TB = -10+15 #[Newton meter]\n", + "\n", + "# Applying +ΣM_x = 0 to segment CD\n", + "TC = 25 #[Newton meter]\n", + "\n", + "# Result\n", + "print\"TB = \",(TB),\"N.m\"\n", + "print\"TC = \",(TC),\"N.m\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 7.3 Page no 263" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NB = 0 kN\n", + "VB = 5 kN\n", + "MB = 15 kN.m\n", + "NC = 0 kN\n", + "VC = 1 kN\n", + "MC = 15 kN.m\n" + ] + } + ], + "source": [ + "# Example 7.3\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Applying +ΣMD(counterclockwise) = 0 Refer fig 7-6b\n", + "A_y = (9+6*6)/9\n", + "\n", + "# Consider segment AB\n", + "# Applying +ΣF_x(right) = 0\n", + "NB = 0 #[kilo Newton]\n", + "# Applying +ΣF_y(upward) = 0\n", + "VB = 5 #[kilo Newton]\n", + "# Applying +ΣMB(counterclockwise) = 0 \n", + "MB = 5*3 #[kilo Newton meter]\n", + "\n", + "# Consider segment AC\n", + "# Applying +ΣF_x(right) = 0\n", + "NC = 0 #[kilo Newton]\n", + "# Applying +ΣF_y(upward) = 0\n", + "VC = 6-5 #[kilo Newton]\n", + "# Applying +ΣMC(counterclockwise) = 0\n", + "MC = 5*3 #[kilo Newton meter]\n", + "\n", + "# Result\n", + "print\"NB = \",(NB),\"kN\"\n", + "print\"VB = \",(VB),\"kN\"\n", + "print\"MB = \",(MB),\"kN.m\"\n", + "print\"NC = \",(NB),\"kN\"\n", + "print\"VC = \",(VC),\"kN\"\n", + "print\"MC = \",(MC),\"kN.m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 7.4 Page no 264" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NB = 266.7 N\n", + "VB = 0 N\n", + "MB = 400 N.m\n" + ] + } + ], + "source": [ + "# Example 7.4\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Refer fig 7-7b\n", + "# Applying +ΣMA(counterclockwise) = 0\n", + "FDC = (400*4)/((3/5)*8) #[Newton]\n", + "# Applying +ΣF_x(right) = 0\n", + "A_x = (4/5)*333.3 #[Newton]\n", + "# Applying +ΣF_y(upward) = 0\n", + "A_y = 400-((3/5)*333.3) #[Newton]\n", + "\n", + "# Applying equations of equilibrium to segment AB\n", + "# Applying +ΣF_x(right) = 0\n", + "NB = 266.7 #[Newton]\n", + "# Applying +ΣF_y(upward) = 0\n", + "VB = 200-200 #[Newton]\n", + "# Applying +ΣMB(counterclockwise) = 0\n", + "MB = 200*4-200*2 #[Newton meter]\n", + "\n", + "# Result\n", + "print\"NB = \",(NB),\"N\"\n", + "print\"VB = \",(VB),\"N\"\n", + "print\"MB = \",(MB),\"N.m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 7.5 Page no 265" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "VE = 600.0 N\n", + "NE = 600.0 N\n", + "ME = 300.0 N.m\n" + ] + } + ], + "source": [ + "# Example 7.5\n", + "import math\n", + "\n", + "# Calculation\n", + "# Using +ΣF_y(upward) = 0 Refer fig 7-8b\n", + "R = round(600/math.sin(math.pi*45/180),1) #[Newton]\n", + "# Applying equations of equilibrium \n", + "# Applying +ΣF_x(right) = 0\n", + "VE = round(R*math.cos(math.pi*45/180),1) #[Newton]\n", + "# Applying +ΣF_y(upward) = 0\n", + "NE = round(R*math.sin(math.pi*45/180),1) #[Newton]\n", + "# Applying +ΣME(counterclockwise) = 0\n", + "ME = round(R*math.cos(math.pi*45/180)*0.5,1) #[Newton meter]\n", + "\n", + "# Result\n", + "print\"VE = \",(VE),\"N\"\n", + "print\"NE = \",(NE),\"N\"\n", + "print\"ME = \",(ME),\"N.m\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 7.6 Page no 266" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MA_x = -19.1 kN.m\n", + "MA_y = 70.9 kN.m\n", + "MA_z = -40.5 kN.m\n" + ] + } + ], + "source": [ + "# Example 7.6\n", + "from __future__ import division\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "W = 650*9.81 #[kilo Newton]\n", + "Fw = 900/(6*2.5) #[kilo Newton]\n", + "# Using +ΣF_x(right) = 0\n", + "FA_x = 13.5 #[kilo Newton]\n", + "FA_y = 0 #[kilo Newton]\n", + "FA_z = 6.376 #[kilo Newton]\n", + "# Using ΣMA = 0, MA + r X (Fw + W)\n", + "a = np.cross([0,3,5.25],[-13.5,0,6.376])\n", + "MA_x = round(-a[0],1) #[kilo Newton meter]\n", + "MA_y = round(-a[1],1) #[kilo Newton meter]\n", + "MA_z = round(-a[2],1) #[kilo Newton meter]\n", + "\n", + "# Result\n", + "print\"MA_x = \",(MA_x),\"kN.m\"\n", + "print\"MA_y = \",(MA_y),\"kN.m\"\n", + "print\"MA_z = \",(MA_z),\"kN.m\" # Correction in MA_z\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 7.13 Page no 286" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TBC = 10.2 kN\n", + "TAB = 13.6 kN\n", + "TCD = 9.5 kN\n", + "TED = 11.8 kN\n" + ] + } + ], + "source": [ + "# Example 7.13\n", + "from __future__ import division\n", + "import math \n", + "\n", + "# Calculation\n", + "# Consider free body diagram Refer fig 7-21b\n", + "# Using +ΣME(counterclockwise) = 0\n", + "A_y = (4*15+15*10+3*2)/18 #[kilo Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "E_y = -12+4+15+3 #[kilo Newton]\n", + "\n", + "# Consider leftmost section which cuts cable BC Refer fig 7-21b\n", + "# Using +ΣMC(counterclockwise) = 0\n", + "A_x = (12*8-4*5)/12 #[kilo Newton]\n", + "thetaBC = round(math.degrees(math.atan((12-4)/6.33)),1) #[Degrees]\n", + "# Using +ΣF_x(right) = 0\n", + "TBC = round(6.33/math.cos(math.pi*thetaBC/180),1) #[kilo Newton]\n", + "thetaAB = round(math.degrees(math.atan(12/6.33)),1) #[Degrees]\n", + "\n", + "# Applying +ΣF_x(right) = 0 at point A\n", + "TAB = round(12/math.sin(math.pi*thetaAB/180),1) #[kilo Newton]\n", + "thetaCD = round(math.degrees(math.atan((-10.2*math.sin(math.pi*51.6/180)+15)/(10.2*math.cos(math.pi*51.6/180)))),1) #[Degrees]\n", + "\n", + "# Applying +ΣF_x(right) = 0 at point C\n", + "TCD = round((10.2*math.cos(math.pi*51.6/180))/math.cos(math.pi*thetaCD/180),1) #[kilo Newton]\n", + "thetaED = round(math.degrees(math.atan(10/6.33)),1) #[Degrees]\n", + "\n", + "# Applying +ΣF_x(right) = 0 at point E\n", + "TED = round(10/math.sin(math.pi*thetaED/180),1) #[kilo Newton]\n", + "\n", + "print\"TBC = \",(TBC),\"kN\"\n", + "print\"TAB = \",(TAB),\"kN\"\n", + "print\"TCD = \",(TCD),\"kN\"\n", + "print\"TED = \",(TED),\"kN\" " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_8_Friction.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_8_Friction.ipynb new file mode 100644 index 00000000..f2059979 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_8_Friction.ipynb @@ -0,0 +1,406 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 8 Friction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 8.1 Page No 305" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F = 69.3 N\n", + "NC = 236.2 N\n", + "x = -9.08 mm\n" + ] + } + ], + "source": [ + "# Example 8.1\n", + "import math\n", + "\n", + "# Variable Declaration\n", + "P = 80 #[Newton]\n", + "\n", + "# Calculation\n", + "# Using +ΣF_x(right) = 0+ΣMO(counterclockwise) = 0\n", + "F = round(80*math.cos(math.pi*30/180),1) #[Newton]\n", + "\n", + "# Using +ΣF_y(upward) = 0\n", + "NC = round(80*math.sin(math.pi*30/180)+196.2,1) #[Newton]\n", + "\n", + "# Using +ΣMO(counterclockwise) = 0\n", + "x = (80*math.cos(math.pi*30/180)*0.2-80*math.sin(math.pi*30/180)*0.4)/NC #[meter]\n", + "\n", + "# Result\n", + "print\"F = \",(F),\"N\"\n", + "print\"NC = \",(NC),\"N\"\n", + "print\"x = \",(round(x*1000,2)),\"mm\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 8.2 Page No 306" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "us = 0.466\n" + ] + } + ], + "source": [ + "# Ex 8.2\n", + "import math\n", + "\n", + "# Calculation\n", + "# W*sin25 = us(W*cos25)\n", + "us = round(math.tan(math.pi*25/180),3)\n", + "\n", + "# Result\n", + "print\"us = \",(us)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 8.3 Page No 307" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "us = 0.228\n" + ] + } + ], + "source": [ + "# Ex 8.3\n", + "import numpy as np\n", + "\n", + "# Calculation\n", + "coeff = [1, -4.619, 1]\n", + "us = np.roots(coeff)\n", + "\n", + "# Result\n", + "# Finding the smallest root\n", + "print\"us = \",(round(min(us),3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 8.4 Page No 308" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "us_min = 0.268\n", + "ug_min = 0.0893\n" + ] + } + ], + "source": [ + "# Ex 8.4\n", + "import math\n", + "\n", + "# Calculation\n", + "# Using +ΣF_x(right) = 0,FA = F and NA = N for bottom pipe\n", + "# us_min = F/N\n", + "us_min = round(math.sin(math.pi*30/180)/(1+math.cos(math.pi*30/180)),3)\n", + "# Let smallest required coefficient of static friction be ug_min\n", + "# ug_min = F/NC\n", + "ug_min = round(0.2679*0.5/1.5,4)\n", + "\n", + "# Result\n", + "print\"us_min = \",(us_min)\n", + "print\"ug_min = \",(ug_min)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 8.5 Page No 309" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P = 266.7 N\n", + "NC = 400 N\n", + "FC = 200.0 N\n", + "FB = 66.7 N\n" + ] + } + ], + "source": [ + "# Ex 8.5\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "uB = 0.2\n", + "uC = 0.5\n", + "\n", + "# Calculation\n", + "# Post slips only at B\n", + "# FB = uB*NB\n", + "FB = uB*400 #[Newton]\n", + "# Using +ΣMC(counterclockwise) = 0\n", + "P = FB/0.25 #[Newton]\n", + "# Using +ΣF_y(upward) = 0\n", + "NC = 400 #[Newton]\n", + "# Using +ΣF_x(right) = 0\n", + "FC = P-FB #[Newton]\n", + "\n", + "# Post slips only at C\n", + "FC = uC*NC #[Newton]\n", + "# Using +ΣF_x(right) = 0 and # Using +ΣMC(counterclockwise) = 0\n", + "a = np.array([[1,-1],[-0.25,1]])\n", + "b = np.array([200,0])\n", + "x = np.linalg.solve(a, b)\n", + "P = round(x[0],1) #[Newton]\n", + "FB = round(x[1],1) #[Newton]\n", + "\n", + "# Result\n", + "print\"P = \",(P),\"N\"\n", + "print\"NC = \",(NC),\"N\"\n", + "print\"FC = \",(FC),\"N\"\n", + "print\"FB = \",(FB),\"N\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 8.6 Page No 310" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NA = 1084.5 N\n", + "FA = 162.7 N\n", + "FB = 162.7 N\n", + "P = 498.2 N\n" + ] + } + ], + "source": [ + "# Ex 8.6\n", + "import math\n", + "import numpy as np\n", + "\n", + "# Variable Declaration\n", + "usA = 0.15\n", + "usB = 0.4\n", + "\n", + "# Calculation\n", + "\n", + "# Pipe rolls up incline\n", + "# Using +ΣF_x(right) = 0, +ΣMO(counterclockwise) = 0 and FB = 0.4*P\n", + "a = np.array([[-1,1],[-400,0.4*400]])\n", + "b = np.array([981*math.sin(math.pi*20/180),0])\n", + "x = np.linalg.solve(a, b)\n", + "FA = round(x[0],1) #[Newton]\n", + "P = round(x[1],1) #[Newton]\n", + "FB = FA #[Newton]\n", + "NA = round(FB+981*math.cos(math.pi*20/180),1) #[Newton]\n", + "P = round(981*math.sin(math.pi*20/180)+FA,1) #[Newton]\n", + "\n", + "# Pipe slides up incline\n", + "# Using +ΣMO(counterclockwise) = 0 and FA = 0.15*NA\n", + "a = np.array([[-0.15*400,400],[1,-1]])\n", + "b = np.array([0,981*math.cos(math.pi*20/180)])\n", + "x = np.linalg.solve(a, b)\n", + "NA = round(x[0],1) #[Newton]\n", + "FB = round(x[1],1) #[Newton]\n", + "FA = FB #[Newton]\n", + "P = round(FA+981*math.sin(math.pi*20/180),1) #[Newton]\n", + "\n", + "# Result\n", + "print\"NA = \",(NA),\"N\"\n", + "print\"FA = \",(FA),\"N\"\n", + "print\"FB = \",(FB),\"N\"\n", + "print\"P = \",(P),\"N\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 8.8 Page No 319" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "M = 6.38 N.m\n" + ] + } + ], + "source": [ + "# Ex 8.8\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "us = 0.25\n", + "W = 2000 #[Newton]\n", + "r = 5 #[millimeter]\n", + "\n", + "# Calculation\n", + "phi_s = round(math.degrees(math.atan(us)),2)\n", + "theta = round(math.degrees(math.atan(2/(2*math.pi*5))),2)\n", + "M = 2*W*r*math.tan(math.pi*(phi_s+theta)/180) #[Newton millimeter]\n", + "\n", + "# Result\n", + "print\"M = \",round(M/1000,2),\"N.m\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 8.9 Page No 324" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "m = 15.7 kg\n" + ] + } + ], + "source": [ + "# Ex 8.9\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "us = 0.25\n", + "\n", + "# Calculation\n", + "T1 = round(500/(math.exp(us*(3/4)*math.pi)),1)\n", + "W = round(T1/(math.exp(us*(3/4)*math.pi)),1)\n", + "m = round(W/9.81,1)\n", + "\n", + "# Result\n", + "print\"m = \",(m),\"kg\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_9_Center_of_Gravity_and_Centroid.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_9_Center_of_Gravity_and_Centroid.ipynb new file mode 100644 index 00000000..92c855af --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/Chapter_9_Center_of_Gravity_and_Centroid.ipynb @@ -0,0 +1,537 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 9 Center of Gravity and Centroid" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.1 Page No 337" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xbar = 0.41 m\n", + "ybar = 0.574 m\n" + ] + } + ], + "source": [ + "# Example 9.1\n", + "from scipy import integrate\n", + "import math\n", + "\n", + "# Calculation\n", + "a = lambda y: y**(2)*math.sqrt(4*y**(2)+1)\n", + "b = lambda y: math.sqrt(4*y**(2)+1)\n", + "xbar = integrate.quad(a, 0, 1)[0]/integrate.quad(b, 0, 1)[0] #[meter]\n", + "\n", + "c = lambda y: y*math.sqrt(4*y**(2)+1)\n", + "d = lambda y: math.sqrt(4*y**(2)+1)\n", + "ybar = integrate.quad(c, 0, 1)[0]/integrate.quad(d, 0, 1)[0] #[meter]\n", + "\n", + "# Result\n", + "print\"xbar = \",round(xbar,3),\"m\"\n", + "print\"ybar = \",round(ybar,3),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.5 Page No 342" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "xbar = 0.75 m\n", + "ybar = 0.3 m\n", + "\n", + "Solution 2\n", + "xbar = 0.75 m\n", + "ybar = 0.3 m\n" + ] + } + ], + "source": [ + "# Example 9.5\n", + "from scipy import integrate\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Solution 1\n", + "a = lambda x: x**(3)\n", + "b = lambda x: x**(2)\n", + "xbar = integrate.quad(a, 0, 1)[0]/integrate.quad(b, 0, 1)[0] #[meter]\n", + "c = lambda x: (x**(4))/2\n", + "d = lambda x: x**(2)\n", + "ybar = integrate.quad(c, 0, 1)[0]/integrate.quad(d, 0, 1)[0] #[meter]\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1\"\n", + "print\"xbar = \",round(xbar,3),\"m\"\n", + "print\"ybar = \",round(ybar,3),\"m\\n\"\n", + "\n", + "# Solution 2\n", + "a = lambda y: (1-y)/2\n", + "b = lambda y: 1-math.sqrt(y)\n", + "xbar = integrate.quad(a, 0, 1)[0]/integrate.quad(b, 0, 1)[0] #[meter]\n", + "c = lambda y: y-y**(3/2)\n", + "d = lambda y: 1-math.sqrt(y)\n", + "ybar = integrate.quad(c, 0, 1)[0]/integrate.quad(d, 0, 1)[0] #[meter]\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2\"\n", + "print\"xbar = \",round(xbar,3),\"m\"\n", + "print\"ybar = \",round(ybar,3),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.6 Page No 343" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution 1\n", + "xbar = 0.5 m\n", + "\n", + "Solution 2\n", + "xbar = 0.5 m\n" + ] + } + ], + "source": [ + "# Example 9.6\n", + "from scipy import integrate\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "# Solution 1\n", + "a = lambda x: x*(x-x**(2))\n", + "b = lambda x: (x-x**(2))\n", + "xbar = integrate.quad(a, 0, 1)[0]/integrate.quad(b, 0, 1)[0] #[meter]\n", + "\n", + "\n", + "# Result Solution 1\n", + "print\"Solution 1\"\n", + "print\"xbar = \",round(xbar,3),\"m\\n\"\n", + "\n", + "\n", + "# Solution 2\n", + "a = lambda y: ((math.sqrt(y)+y)/2)*(math.sqrt(y)-y)\n", + "b = lambda y: math.sqrt(y)-y\n", + "xbar = integrate.quad(a, 0, 1)[0]/integrate.quad(b, 0, 1)[0] #[meter]\n", + "\n", + "\n", + "# Result Solution 2\n", + "print\"Solution 2\"\n", + "print\"xbar = \",round(xbar,3),\"m\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.7 Page No 344" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ybar = 66.7 mm\n" + ] + } + ], + "source": [ + "# Example 9.7\n", + "from scipy import integrate\n", + "import math\n", + "\n", + "# Calculation\n", + "a = lambda y: 100*math.pi*y**(2)\n", + "b = lambda y: 100*math.pi*y\n", + "ybar = integrate.quad(a, 0, 100)[0]/integrate.quad(b, 0, 100)[0] #[millimeter]\n", + "\n", + "# Result\n", + "print\"ybar = \",round(ybar,1),\"mm\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Ex 9.8 Page No 346" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zbar = 0.667 m\n" + ] + } + ], + "source": [ + "# Example 9.8\n", + "from scipy import integrate\n", + "import math\n", + "\n", + "# Calculation\n", + "a = lambda z: z*200*z*math.pi*0.5**(2)\n", + "b = lambda z: 200*z*math.pi*0.5**(2)\n", + "zbar = integrate.quad(a, 0, 1)[0]/integrate.quad(b, 0, 1)[0] #[meter]\n", + "\n", + "# Result\n", + "print\"zbar = \",round(zbar,3),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.9 Page No 352" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xbar = 45.5 mm\n", + "ybar = -22.5 mm\n", + "zbar = -0.805 mm\n" + ] + } + ], + "source": [ + "# Example 9.9\n", + "import math\n", + "\n", + "# Calculation\n", + "xbar = (60*math.pi*60+0*40+0*20)/(math.pi*60+40+20) #[millimeter]\n", + "ybar = (-38.2*math.pi*60+20*40+40*20)/(math.pi*60+40+20) #[millimeter]\n", + "zbar = (0*math.pi*60+0*40+-10*20)/(math.pi*60+40+20) #[millimeter]\n", + "\n", + "# Result\n", + "print\"xbar = \",round(xbar,1),\"mm\"\n", + "print\"ybar = \",round(ybar,1),\"mm\"\n", + "print\"zbar = \",round(zbar,3),\"mm\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.10 Page No 353" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xbar = -0.348 m\n", + "ybar = 1.22 m\n" + ] + } + ], + "source": [ + "# Example 9.10\n", + "\n", + "# Calculation\n", + "xbar = (1*0.5*3*3+(-1.5)*3*3+(-2.5)*(-2)*1)/(0.5*3*3+3*3+(-2)*1) #[meter]\n", + "ybar = (1*0.5*3*3+1.5*3*3+2*(-2)*1)/(0.5*3*3+3*3+(-2)*1) #[meter]\n", + "\n", + "# Result\n", + "print\"xbar = \",round(xbar,3),\"m\"\n", + "print\"ybar = \",round(ybar,2),\"m\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.11 Page No 354" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zbar = 14.6 mm\n" + ] + } + ], + "source": [ + "# Example 9.11\n", + "import math\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "pc = 8 #[milligram per meter cube]\n", + "ph = 4 #[milligram per meter cube]\n", + "\n", + "# Calculation\n", + "zbar = (50*pc*10**(-6)*(1/3)*math.pi*50**(2)*200 + (-18.75)*ph*10**(-6)*(2/3)*math.pi*50**(3) + 125*(-pc)*10**(-6)*(1/3)*math.pi*25**(2)*100 + 50*(-pc)*10**(-6)*math.pi*25**(2)*100)/(pc*10**(-6)*(1/3)*math.pi*50**(2)*200+ph*10**(-6)*(2/3)*math.pi*50**(3)+(-pc)*10**(-6)*(1/3)*math.pi*25**(2)*100+(-pc)*10**(-6)*math.pi*25**(2)*100) #[millimeter]\n", + "\n", + "# Result\n", + "print\"zbar = \",round(zbar,1),\"mm\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.13 Page No 368" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solutuon 1\n", + "FR = 154.5 kN\n", + "h = 1.3 m\n", + "\n", + "Solutuon 2\n", + "FR = 154.5 kN\n", + "h = 1.3 m\n" + ] + } + ], + "source": [ + "# Example 9.13\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "b = 1.5 #[meter]\n", + "pw = 1000 #[kilogram per meter cube]\n", + "# Calculation\n", + "# Solution 1\n", + "# Let water pressure at depth A be pA and water pressure at depth B be pB\n", + "pA = pw*9.81*2/1000 #[kilo Pascal]\n", + "pB = pw*9.81*5/1000 #[kilo Pascal]\n", + "wA = round(b*pA,2) #[kilo Newton per meter]\n", + "wB = round(b*pB,2) #[kilo Newton per meter]\n", + "# let FR be area of trapezoid\n", + "FR = round((1/2)*3*(wA+wB),1) #[kilo Newton]\n", + "# Let h be force acting through centroid\n", + "h = round((1/3)*((2*wA+wB)/(wA+wB))*3,1) #[meter]\n", + "\n", + "# Result Solution 1\n", + "print\"Solutuon 1\"\n", + "print\"FR = \",(FR),\"kN\"\n", + "print\"h = \",(h),\"m\\n\"\n", + "\n", + "# Solution 2\n", + "FRe = round(wA*3,1) #[kilo Newton]\n", + "Ft = round((1/2)*(wB-wA)*3,1) #[kilo Newton]\n", + "FR = FRe + Ft #[kilo Newton]\n", + "# +ΣMRB(clockwise) = ΣMB\n", + "h = round((FRe*1.5+Ft*1)/FR,1) #[meter]\n", + "\n", + "# Result Solution 2\n", + "print\"Solutuon 2\"\n", + "print\"FR = \",(FR),\"kN\" \n", + "print\"h = \",(h),\"m\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.14 Page No 369" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FR = 231.0 kN\n" + ] + } + ], + "source": [ + "# Example 9.14\n", + "from __future__ import division\n", + "\n", + "# Variable Declaration\n", + "b = 5 #[meter]\n", + "pw = 1020 #[kilogram per meter cube]\n", + "\n", + "# Calculation\n", + "pB = round(pw*9.81*3/1000,2) #[kilo Pascal]\n", + "wB = round(b*pB,1) #[kilo Newton per meter]\n", + "F_x = round((1/2)*3*wB,1) #[kilo Newton]\n", + "F_y = round(pw*9.81*5*(1/3)*1*3/1000,1) #[kilo Newton]\n", + "FR = round(math.sqrt(F_x**(2)+F_y**(2)),0) #[kilo Newton]\n", + "\n", + "# Result\n", + "print\"FR = \",(FR),\"kN\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ex 9.15 Page No 370" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F = 1.64 kN\n", + "xbar = 0\n", + "zbar = 0.5 m\n" + ] + } + ], + "source": [ + "# Example 9.15\n", + "from scipy import integrate\n", + "from __future__ import division\n", + "\n", + "# Calculation\n", + "a = lambda z: 9810*(z-z**(2))\n", + "F = round(integrate.quad(a, 0, 1)[0],2) #[Newton]\n", + "\n", + "# Resultant passes through centroid of volume\n", + "xbar = 0\n", + "a = lambda z: (9810/1635)*(z**(2)-z**(3))\n", + "zbar = round(integrate.quad(a, 0, 1)[0],1) #[meter]\n", + "\n", + "# Result\n", + "print\"F = \",(round(F/1000,2)),\"kN\"\n", + "print\"xbar = \",(xbar)\n", + "print\"zbar = \",(zbar),\"m\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/screenshots/plot1.png b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/screenshots/plot1.png Binary files differnew file mode 100644 index 00000000..deb1e879 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/screenshots/plot1.png diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/screenshots/plot2.png b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/screenshots/plot2.png Binary files differnew file mode 100644 index 00000000..b75faff2 --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/screenshots/plot2.png diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/screenshots/plot3.png b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/screenshots/plot3.png Binary files differnew file mode 100644 index 00000000..c3b384fc --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibler_and_Gupta/screenshots/plot3.png |
