diff options
Diffstat (limited to 'Engineering_Mechanics_Statics_and_Dynamics_by_Hibbeler_and_Gupta/Chapter_2.ipynb')
| -rw-r--r-- | Engineering_Mechanics_Statics_and_Dynamics_by_Hibbeler_and_Gupta/Chapter_2.ipynb | 1058 |
1 files changed, 1058 insertions, 0 deletions
diff --git a/Engineering_Mechanics_Statics_and_Dynamics_by_Hibbeler_and_Gupta/Chapter_2.ipynb b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibbeler_and_Gupta/Chapter_2.ipynb new file mode 100644 index 00000000..8b8efd6a --- /dev/null +++ b/Engineering_Mechanics_Statics_and_Dynamics_by_Hibbeler_and_Gupta/Chapter_2.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 +} |