From 4001048f8209fe2825519adff366c99c8c84ab9f Mon Sep 17 00:00:00 2001 From: Trupti Kini Date: Tue, 2 Aug 2016 23:30:25 +0600 Subject: Added(A)/Deleted(D) following books A Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter2.ipynb A Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter3.ipynb A Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter4.ipynb A Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter5.ipynb A Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter6.ipynb A Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter7.ipynb A Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter2.png A Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter3.png A Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter4.png A sample_notebooks/Harshitgarg/Chapter_1-INTRODUCTION_TO_MECHANICS_OF_SOLIDS__1.ipynb --- .../Chapter2.ipynb | 768 +++++++++++++++++++++ .../Chapter3.ipynb | 231 +++++++ .../Chapter4.ipynb | 517 ++++++++++++++ .../Chapter5.ipynb | 571 +++++++++++++++ .../Chapter6.ipynb | 643 +++++++++++++++++ .../Chapter7.ipynb | 177 +++++ .../screenshots/chapter2.png | Bin 0 -> 58569 bytes .../screenshots/chapter3.png | Bin 0 -> 63582 bytes .../screenshots/chapter4.png | Bin 0 -> 46754 bytes ..._1-INTRODUCTION_TO_MECHANICS_OF_SOLIDS__1.ipynb | 366 ++++++++++ 10 files changed, 3273 insertions(+) create mode 100644 Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter2.ipynb create mode 100644 Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter3.ipynb create mode 100644 Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter4.ipynb create mode 100644 Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter5.ipynb create mode 100644 Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter6.ipynb create mode 100644 Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter7.ipynb create mode 100644 Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter2.png create mode 100644 Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter3.png create mode 100644 Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter4.png create mode 100644 sample_notebooks/Harshitgarg/Chapter_1-INTRODUCTION_TO_MECHANICS_OF_SOLIDS__1.ipynb diff --git a/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter2.ipynb b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter2.ipynb new file mode 100644 index 00000000..dd9dead5 --- /dev/null +++ b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter2.ipynb @@ -0,0 +1,768 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 2 : Electric Circuits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1 : pg 6" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current in resistance Ra=1.0 ohm is ,(A)= 0.105\n" + ] + } + ], + "source": [ + "# Example 2.1 :current\n", + "#calculate the current \n", + "# given :\n", + "import numpy\n", + "#15*I1-5*I2=10 loop 1 equation\n", + "#20*I2-5*I1-5*I3=0 loop 2 equation\n", + "#10*I3-5*I2=0 loop 3 equation\n", + "vs=10.;#voltage in volts\n", + "R1=10.;#resistance in ohm\n", + "R2=5.;#resistance in ohm\n", + "R3=10.;#resistance in ohm\n", + "R4=5.;#resistance in ohm\n", + "R5=4.;#resistance in ohm\n", + "Ra=1.;#resistance in ohm\n", + "#calculations\n", + "A=([[R1+R2, R2-R1, 0],[R2-R1, R2+R3+R4, -R4],[R4-(R5+Ra), -R4, R4+R5+Ra]]);#making equations\n", + "nb=7.;#number of branches\n", + "nn=5.;#number of nodes\n", + "nl=nb-(nn-1);#number of loops\n", + "nvs=1.;#number of voltage sources\n", + "nivs=nn-1-nvs;#number of independent voltage variables\n", + "B=([[vs],[0],[0]]);#making equations\n", + "X=numpy.dot(numpy.linalg.inv(A),B);#solving equations\n", + "I3=X[2,0];#calculating currrent\n", + "#results\n", + "print \"current in resistance Ra=1.0 ohm is ,(A)=\",round(I3,3)\n", + "#directions of the current are 2 to 3 and 3 to 4 respectively\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2 : pg 6" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current through Rx is(by node voltage method), (A)= 3.956\n", + "current through Rx is (by loop current method),(A) = 3.956\n" + ] + } + ], + "source": [ + "# Example 2.2 :current\n", + "#calculate the current in both cases\n", + "import numpy\n", + "# given :\n", + "vs1=72.;#voltage in volts\n", + "vs2=40.;#voltage in volts\n", + "R1=36.;#resistance in ohm\n", + "R2=10.;#resistance in ohm\n", + "ig=2.;#current in amperes\n", + "Rx=8.;#resistance in ohm\n", + "#calculations\n", + "#(va-72)/36+(va-40)/10 -2 +va/8=0 node equation at 1\n", + "va=((R2*Rx*vs1)+(R1*Rx*vs2)+(R1*R2*Rx*ig))/((R2*Rx)+(R1*Rx)+(R1*R2));#voltage in volts\n", + "ix1=va/Rx;#current in amperes\n", + "#(R1+R2)*I1-R2*I2+vs2=vs1 loop equation 1\n", + "#R2*I2-R2*I1+Ix*Rx=vs2 loop equation 2\n", + "#Ix=I2+2\n", + "A=([[R1+R2, -R2],[-R2, R2+Rx]]);#making equations\n", + "B=([[vs1-vs2],[vs2-2*Rx]]);#making equations\n", + "X=numpy.dot(numpy.linalg.inv(A),B);#solving equations\n", + "ix2=X[1,0]+ig;#current in amperes\n", + "print \"current through Rx is(by node voltage method), (A)=\",round(ix1,3)\n", + "print \"current through Rx is (by loop current method),(A) =\",round(ix2,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3 : pg 7" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current through Rl is (from b to a),(A)= 0.359\n" + ] + } + ], + "source": [ + "# Example 2.3 :current\n", + "#calculate the current\n", + "import numpy\n", + "# given :\n", + "vs1=10;#voltage in volts\n", + "i5=2;#current in amperes\n", + "i2=i5;#current\n", + "r1=1;#resistance in ohms\n", + "r2=5;#resistance in ohms\n", + "r3=5;#resistance in ohms\n", + "rl=10;#resistance in ohms\n", + "r4=5;#resistance ohms\n", + "#calculations\n", + "#(r1+r2+r3)*i1-r2*i2-r3*i3=vs1 loop equaion 1\n", + "#-r2*i1-(r1+r2)*i2+(rl+r2+r3)*i3=0 loop equation 2\n", + "A=([[4*(r1+r2+r3), -r2*4],[-r2, (rl+r2+r3)]]);#making equations\n", + "B=([[4*(vs1+r2*i2)],[i2*(r2+r3)]]);#making equations\n", + "X=numpy.dot(numpy.linalg.inv(A),B);#solving equations\n", + "il=i2-X[1,0];#calculating current\n", + "#results\n", + "print \"current through Rl is (from b to a),(A)=\",round(il,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4 : pg 8" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Applying Thevenins Theorem \n", + "current through Rx is, (A) 3.956\n", + "Applying Nortons Theorem \n", + "current through Rx is, (A) = 3.956\n" + ] + } + ], + "source": [ + "# Example 2.4 :current\n", + "#calculate the current\n", + "# given :\n", + "vs1=72.;#voltage in volts\n", + "vs2=40.;#voltage in volts\n", + "R1=36.;#resistance in ohms\n", + "R2=10.;#resistance in ohms\n", + "ig=2.;#current in amperes\n", + "Rx=8.;#resistance in ohms\n", + "#calculations and results\n", + "print \"Applying Thevenins Theorem \"\n", + "#(vs1-voc)/R1+(v40-voc)/R2 +2 =0 node equation at 1\n", + "voc=(R2*vs1+R1*vs2+R1*R2*ig)/(R1+R2);#voltage in volts\n", + "req=(R1*R2)/(R1+R2);#resistance in ohms\n", + "ix1=(voc)/(req+Rx);#resistance in ohms\n", + "print \"current through Rx is, (A)\",round(ix1,3)\n", + "print \"Applying Nortons Theorem \"\n", + "Is=(vs1/R1)+(vs2/R2)+ig;#current in amperes\n", + "ix2=(req*(Is/(Rx+req)));#current in amperes\n", + "print \"current through Rx is, (A) =\",round(ix2,3)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5 : pg 8" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(a) Applying Thevenins Theorem \n", + "Thevenin equivalent open circuit voltage is, (V)= 5.0\n", + "Thevenin equivalent resistance is,(Ohm)= 50.0\n", + "(b) Applying Nortons Theorem \n", + "Norton short circuit current is,(A)= 0.1\n", + "Norton equivalent resistance is,(Ohm)= 50.0\n" + ] + } + ], + "source": [ + "# Example 2.5 :Thevenin's and Norton's Equivalent\n", + "#calculate the current in all cases\n", + "# given :\n", + "vs1=10.;#voltage in volts\n", + "R1=50.;#resistance in ohms\n", + "R2=50.;#resistance in ohms\n", + "R3=25.;#resistance in ohms\n", + "#calculations and results\n", + "print \"(a) Applying Thevenins Theorem \"\n", + "voc=(R1/(R1+R2))*vs1;#voltage in volts\n", + "req=((R1*R2)/(R1+R2))+R3;#resistance in ohms\n", + "print \"Thevenin equivalent open circuit voltage is, (V)=\",voc\n", + "print \"Thevenin equivalent resistance is,(Ohm)=\",req\n", + "print \"(b) Applying Nortons Theorem \"\n", + "Isc=((vs1)/(R1+(R1*R3)/(R1+R3)))*(R1/(R1+R3));#\n", + "req=((R1*R2)/(R1+R2))+R3;#resistance in ohms\n", + "print \"Norton short circuit current is,(A)=\",Isc\n", + "print \"Norton equivalent resistance is,(Ohm)=\",req\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6 : pg 10" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current through Rx is (from A to B),(mA)= 0.299\n" + ] + } + ], + "source": [ + "# Example 2.6 :current\n", + "#calculate the current \n", + "# given :\n", + "vs1=10.;#voltage volts\n", + "r1=100.;#resistance in ohms\n", + "r2=600.;#resistance in ohms\n", + "r3=150.;#resistance in ohms\n", + "r4=850.;#resistance in ohms\n", + "rx=50.;#resistance in ohms\n", + "#calculations\n", + "voc=vs1*((r3/(r1+r3))-(r4/(r2+r4)));#open circuit voltage in volts\n", + "req=((r1*r3)/(r1+r3))+((r2*r4)/(r2+r4));#equivalent resistance in ohms\n", + "ix=voc/(req+rx)*10**3;#current in amperes\n", + "#results\n", + "print \"current through Rx is (from A to B),(mA)=\",round(ix,3)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7 : pg 11" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current is,(A) -1.429\n", + "equivalent resistance is,(ohm)= 1.273\n" + ] + } + ], + "source": [ + "# Example 2.7 :\n", + "#calculate the Norton's Equivalent\n", + "# given :\n", + "vs1=40.;#volts\n", + "vs2=20.;#volts\n", + "r1=2.;#resistance in ohms\n", + "r2=6.;#resistance in ohms\n", + "r3=2.;#resistance in ohms\n", + "r4=2.;#resistance in ohms\n", + "#calculations\n", + "iab=((r1*vs1)/(r2+(r1/2))*((r1+(r3/2))/(r1+r3)));#current in amperes\n", + "iab1=-vs2/r1;#current amperes\n", + "it=iab+iab1;#current amperes\n", + "req1=r1+((r1*r2)/(r1+r2));#equivalent resistance in ohms\n", + "req=(req1*r3)/(req1+r3);#equivalent resistance in ohms\n", + "#results\n", + "print \"current is,(A)\",round(it,3)\n", + "print \"equivalent resistance is,(ohm)=\",round(req,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8 : pg 12" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current is (when t=500 micro seconds),(A)= 0.221\n", + "time at which current will be zero is,(micro-seconds)= 1222.0\n" + ] + } + ], + "source": [ + "# Example 2.8:equation of current and time\n", + "#calculate the current \n", + "from math import exp,ceil\n", + "# given :\n", + "v=100.;#voltage in volts\n", + "r=100.;#resistance in ohms\n", + "l=0.2;#inductance in henrty\n", + "#calculations and results\n", + "T=1/(l/r);#calculating time in seconds\n", + "t=500.;#time in micro seconds\n", + "i1=1-exp(-T*t*10**-6);#current in amperes\n", + "print \"current is (when t=500 micro seconds),(A)=\",round(i1,3)\n", + "v2=50.;#voltage in volts\n", + "x=v2/r;#variable\n", + "x1=x*((v2/r)+i1);#variable \n", + "t1=t+(10**6*(x1/500.));#time in seconds\n", + "print \"time at which current will be zero is,(micro-seconds)=\",ceil(t1)\n", + "#time is caluclated wrong in the textbook as they had not added the values\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9 : pg 15" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time is ,(seconds)= 0.025\n" + ] + } + ], + "source": [ + "# Example 2.9 :time\n", + "#calculate the time required\n", + "from math import log\n", + "# given :\n", + "v=10.;#voltage in volts\n", + "r1=500.;#resistance in ohms\n", + "ix=0.;#current in amperes\n", + "r=700;#resistance in ohms\n", + "c=100;#capacitance in micro farads\n", + "#calculations\n", + "x=1/(r*c*10**-6);#variable\n", + "i=30;#current in mA\n", + "y=(i*10**-3)-(v/r1);#variable\n", + "t=-((log(y*(r/v))));#time in seconds\n", + "t1=t/x;#time in seconds\n", + "#results\n", + "print \"time is ,(seconds)=\",round(t1,3)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10 : pg 18" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "it= 2.697 *e^ -250.0 t*sin 370.81 t A\n" + ] + } + ], + "source": [ + "# Example 2.10 :current equation\n", + "#calculate the current equation\n", + "# given :\n", + "from numpy import roots\n", + "v=100.;#volts\n", + "r=50.;#in ohms\n", + "l=0.1;#henry\n", + "c=50.;#mf\n", + "#calculations\n", + "p = ([1,500.0,2*10**5])\n", + "#p=2*10**5+500*d+d**2;\n", + "x=roots(p)\n", + "c1=0;#at t=0 i=0\n", + "c2=1000/x[0].imag;#\n", + "#results\n", + "print \"it= \",round(c2,3),\"*e^\",x[0].real,\"t*sin\",round(x[0].imag,3),\"t A\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11 : pg 19" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "parts (a) saw tooth wave\n", + "rms value of e is ,(V)= 0.886\n", + "average value of e is ,(V)= 5\n", + "parts (b) half wave rectified sine wave form\n", + "rms value of e is ,(V)= 5.0\n", + "average value of e is ,(V)= 3.183\n" + ] + } + ], + "source": [ + "# Example 2.11 :\n", + "#calculate the average & rms value\n", + "# given :\n", + "from numpy import linspace\n", + "from math import sin,pi,sqrt\n", + "from scipy import integrate\n", + "vm=10;#voltage in volts\n", + "e=vm/2;#voltage in volts\n", + "t=linspace(0,2, num=3);#time range\n", + "#x=intsplin(t,(5*t)**2);#variable\n", + "x=1.571;\n", + "#calculations and results\n", + "rms=sqrt(x/2);#rms value of voltage in volts\n", + "av=vm/2;#average value of voltage in volts\n", + "print \"parts (a) saw tooth wave\"\n", + "print \"rms value of e is ,(V)=\",round(rms,3)\n", + "print \"average value of e is ,(V)=\",av\n", + "t1=0;#initial time in seconds\n", + "t2=pi;#final time in seconds\n", + "t3=2*pi;#time interval\n", + "def function(t):\n", + " return sin(t) *sin(t);\n", + "\n", + "def function2(t):\n", + " return sin(t)\n", + " \n", + "x=integrate.quad(function,t1,t2)[0];#variable\n", + "rms=sqrt((1/(2*pi))*x*vm**2);#rms value of voltage in volts\n", + "av=(10/(2*pi))*integrate.quad(function2,t1,t2)[0];#average value of voltage in volts\n", + "print \"parts (b) half wave rectified sine wave form\"\n", + "print \"rms value of e is ,(V)=\",rms\n", + "print \"average value of e is ,(V)=\",round(av,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12 : pg 20" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + "Impedance is ,(Ohm)= (16.4700606969+2.90411607477j)\n", + "part (b)\n", + "Impedance is ,(Ohm)= (3.53553390593+3.53553390593j)\n" + ] + } + ], + "source": [ + "# Example 2.12 :\n", + "#calculate the Circuit constants\n", + "# given :\n", + "from math import sqrt, cos, sin,pi\n", + "#v=194*cos(800*t+150)V Voltage equation\n", + "#I=11.6*cos(800*t+140)A Current equation\n", + "vm=194/sqrt(2);#voltage in volts\n", + "va=150;#angle in degree\n", + "im=11.6/sqrt(2);#current in amperes\n", + "ia=140;#angle in degree\n", + "#calculations and results\n", + "zm=vm/im;#resistance in ohms\n", + "za=va-ia;#resistance in ohms\n", + "z1=zm*cos(za*pi/180.);#reactance in ohms\n", + "z2=zm*sin(za*pi/180.);#reactance in ohms\n", + "z=z1+1j*z2;#resistance in ohms\n", + "print \"part (a)\"\n", + "print \"Impedance is ,(Ohm)=\",z\n", + "print \"part (b)\"\n", + "#v=6*sin(1000*t+45)V Voltage equation\n", + "#I=12*cos(1000t-90)A current equation\n", + "vm1=60/sqrt(2);#voltage in volts\n", + "va1=45;#angle in degree\n", + "im1=12/sqrt(2);#current in amperes\n", + "ia1=0;#angle in degree\n", + "zm1=vm1/im1;#resistance in ohms\n", + "za1=va1-ia1;#resistance in ohms\n", + "z11=zm1*cos(za1*pi/180.);#reactance in ohms\n", + "z21=zm1*sin(za1*pi/180.);#reactance in ohms\n", + "z22=z11+1j*z21;#impedance in ohms\n", + "print \"Impedance is ,(Ohm)=\",z22\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13 : pg 22" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reading V2 is,(V) 207.123\n", + "reading V4 is 507.123 V or 92.877 V\n" + ] + } + ], + "source": [ + "# Example 2.13 :reading\n", + "#calculate the voltage reading\n", + "# given :\n", + "from math import sqrt\n", + "v1=230.;#voltage in volts\n", + "v2=100.;#voltage in volts\n", + "#calculations\n", + "v2=sqrt(v1**2-v2**2);#voltage in volts\n", + "v3=300.;#voltage in volts\n", + "#results\n", + "print \"reading V2 is,(V)\",round(v2,3)\n", + "print \"reading V4 is \",round(v3+v2,3),\" V or \",round(v3-v2,3),\" V\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 14 : pg 25" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Impedance is ,(Ohm)= (14.1877554161-14.1877554161j)\n", + "capacitance is ,(micro-farads)= 28.1933250377\n" + ] + } + ], + "source": [ + "# Example 2.14 :circuit elements\n", + "#calculate the circuit elements\n", + "# given :\n", + "from math import sqrt,cos,sin,pi\n", + "#v=311*sin(2500*t+170) V voltage equation\n", + "#I=15.5*sin(2500*t-145)A current equation\n", + "vm=311/sqrt(2);#voltage in volts\n", + "va=170.;#angle in degree\n", + "im=15.5/sqrt(2);#current in amperes\n", + "ia=-145.;#angle in degree\n", + "#calculations\n", + "zm=vm/im;#resistance in ohms\n", + "za=(va-ia)-360.;#resistance ohms\n", + "z1=zm*cos(za*pi/180.);#resistance in ohms\n", + "z2=zm*sin(za*pi/180.);#resistance in ohms\n", + "z=z1+1j*z2;#resistance in ohms\n", + "t=2500;#time in seconds\n", + "c=(1/(z.real*t));#capacitance in farads\n", + "#results\n", + "print \"Impedance is ,(Ohm)=\",z\n", + "print \"capacitance is ,(micro-farads)=\",c*10**6\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15 : pg 26" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a) Star\n", + "phase voltage,(V)= 231.0\n", + "phase current,(A)= 5.0\n", + "line voltage ,(V)= 400\n", + "line current,(A)= 4.619\n", + "power ,(W)= 2560.0\n", + "part (b) Delta\n", + "phase voltage,(V)= 400.0\n", + "phase current,(A)= 8.0\n", + "line voltage ,(V)= 400.0\n", + "line current,(A)= 13.856\n", + "power ,(W)= 7680.0\n" + ] + } + ], + "source": [ + "# Example 2.15 :parameters\n", + "#calculate the parameters of phase, line voltage and current, power\n", + "from math import sqrt\n", + "# given :\n", + "z=40+1j*30;#resistance in ohms\n", + "zph=sqrt(z.real**2+z.imag**2);#resistance in ohms\n", + "pf=z.real/zph;#power factor\n", + "v=400;#voltage in volts\n", + "#calculations and results\n", + "vp=v/(sqrt(3));#voltage in volts\n", + "pc=vp/zph;#current in amperes\n", + "lv=v;#voltage in volts\n", + "lc=pc;#current om amperes\n", + "p=sqrt(3)*v*lc*pf;#power in watts\n", + "print \"part (a) Star\"\n", + "print \"phase voltage,(V)=\",round(vp)\n", + "print \"phase current,(A)=\",round(pc)\n", + "print \"line voltage ,(V)=\",lv\n", + "print \"line current,(A)=\",round(lc,3)\n", + "print \"power ,(W)=\",p\n", + "z1=40+1j*30;#ohms\n", + "zph1=sqrt(z1.real**2+z1.imag**2);#ohms\n", + "pf1=z1.real/zph1;#power factor\n", + "v1=400.;#volts\n", + "vp1=v1;#volts\n", + "pc1=vp1/zph1;#amperes\n", + "lv1=v1;#volts\n", + "lc1=pc1*sqrt(3);#amperes\n", + "p1=sqrt(3)*v1*lc1*pf1;#watts\n", + "print \"part (b) Delta\"\n", + "print \"phase voltage,(V)=\",round(vp1)\n", + "print \"phase current,(A)=\",round(pc1)\n", + "print \"line voltage ,(V)=\",lv1\n", + "print \"line current,(A)=\",round(lc1,3)\n", + "print \"power ,(W)=\",p1\n" + ] + } + ], + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter3.ipynb b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter3.ipynb new file mode 100644 index 00000000..603cbe11 --- /dev/null +++ b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter3.ipynb @@ -0,0 +1,231 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 3 : Magnetic Circuits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1 : pg 42" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total ampere-turns required is, (AT)= 2001.15\n" + ] + } + ], + "source": [ + "# Example 3.1;ampere-turns\n", + "#calculate the ampere turns required\n", + "# given :\n", + "from math import pi\n", + "bt=([[2],[2.5],[3.0]])#making equations from Table\n", + "H=([[400],[600],[800]]);#making equations from Tble\n", + "fsl=10**-3;#Flux in Wb\n", + "cal=4*10**-4;#area in m**2\n", + "#calculations \n", + "fdl=fsl/cal;#magnetic field in Tesla\n", + "hl=H[1][0];#AT/m \n", + "pll=0.57;#lenth in meter (path length 2345)\n", + "at2345=pll*hl;#ampere turns\n", + "fcl=2*10**-3;#magnetic field in Wb\n", + "fdcl=fcl/cal;#in Tesla\n", + "hcl=H[0][0];#in AT/m\n", + "lcl=169;#length in mm\n", + "atcl=(lcl*10**-3)*hcl;#ampere turns\n", + "l=1;#length mm\n", + "Hl=((4*pi))*10**-7;#AT/m\n", + "atrg=fcl/Hl;#AT\n", + "tat=at2345+atcl+atrg;#total ampere turns\n", + "#results\n", + "print \"total ampere-turns required is, (AT)=\",round(tat,2)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2 : pg 44" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a) Kb and Ke\n", + "Kh is 0.39\n", + "Ke is 0.00424\n", + "part (b) hystresis and eddy current loss \n", + "hysteresis loss at 25 Hz is , (W)= 9.75\n", + "eddy current loss at 25 Hz is ,(W)= 2.65\n", + "hysteresis loss at 50 Hz is ,(W)= 19.5\n", + "eddy current loss at 50 Hz is ,(W)= 10.6\n", + "part (c) hystresis and eddy current loss \n", + "hysteresis loss per kg at 50 Hz is ,(W)= 0.4875\n", + "eddy current loss per kg at 50 Hz is ,(W)= 0.265\n" + ] + } + ], + "source": [ + "# Example 3.2;\n", + "#calculate the Kb,Ke,hystresis and eddy current loss\n", + "import numpy\n", + "# given :\n", + "f1=50.;#frequency in Hz\n", + "f2=25.;#frequency in Hz\n", + "p1=30.1;#power in W\n", + "p2=12.4;#power in W\n", + "#calculations and results\n", + "A=([[f1, f1**2],[f2, f2**2]]);#making equations\n", + "B=([[p1],[p2]]);##making equations\n", + "X=numpy.dot(numpy.linalg.inv(A),B);#calculating parameters\n", + "print \"part (a) Kb and Ke\"\n", + "print \"Kh is \", X[0,0]\n", + "print \"Ke is \",X[1,0]\n", + "h25=X[0,0]*f2;#calculating parameters\n", + "e25=X[1,0]*f2**2;#calculating parameters\n", + "h50=X[0,0]*f1;#calculating parameters\n", + "e50=X[1,0]*f1**2;#calculating parameters\n", + "print \"part (b) hystresis and eddy current loss \"\n", + "print \"hysteresis loss at 25 Hz is , (W)=\",h25\n", + "print \"eddy current loss at 25 Hz is ,(W)=\",e25\n", + "print \"hysteresis loss at 50 Hz is ,(W)=\",h50\n", + "print \"eddy current loss at 50 Hz is ,(W)=\",e50\n", + "W=40;#kg\n", + "h50=X[0,0]*f1;#calculating parameters\n", + "e50=X[1,0]*f1**2;#calculating parameters\n", + "print \"part (c) hystresis and eddy current loss \"\n", + "print \"hysteresis loss per kg at 50 Hz is ,(W)=\",h50/W\n", + "print \"eddy current loss per kg at 50 Hz is ,(W)=\",e50/W\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3 : pg 46" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hystersis loss is ,(W/kg)= 6.15\n" + ] + } + ], + "source": [ + "# Example 3.3;\n", + "#Calculate the hystresis loss per Kg\n", + "# given :\n", + "l=10.;#lengh in mm\n", + "atm=200.;#AT/m\n", + "a=4800.;#area in m**2\n", + "#calculations\n", + "loss=atm*(l*10**-2)*(a/100);#loss in J/m**3/cycle\n", + "d=7.8*10**3;#kg/m**3\n", + "vikg=1/d;#m**3\n", + "loss1=loss*vikg;#J/cycle\n", + "f=50;#Hz\n", + "tl=loss1*f;#J/s\n", + "#results\n", + "print \"hystersis loss is ,(W/kg)=\",round(tl,2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4 : pg 52" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ampere turn required is, (AT)= 478.731\n" + ] + } + ], + "source": [ + "# Example 3.4;amper-turns\n", + "#calculate the ampere turn required\n", + "# given :\n", + "from math import sqrt, pi\n", + "r=150.;#length in mm\n", + "t=12.;#torque in N-m\n", + "#calculations\n", + "f=t/(r*10**-3);#force in N\n", + "np=2;#no. of poles\n", + "fp=f/np;#force per pole in N\n", + "A=400.;#area mm**2\n", + "mu=4*pi*10**-7;#\n", + "b=sqrt((fp*2*mu)/(A*10**-6));#magnetic field in Tesla\n", + "H=b/mu;#in AT/m\n", + "tar=2*0.6*10**-3;#length in meter\n", + "atr=H*tar;#AT\n", + "#results\n", + "print \"ampere turn required is, (AT)=\",round(atr,3)\n", + "#answer is wrong in the textbook\n" + ] + } + ], + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter4.ipynb b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter4.ipynb new file mode 100644 index 00000000..d8758394 --- /dev/null +++ b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter4.ipynb @@ -0,0 +1,517 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter : Transformers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1 : pg 66" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of primary winding turns are 1720.0\n", + "number of secondary winding turns are 172.0\n" + ] + } + ], + "source": [ + "# Example 4.1;NUMBER OF TURNS\n", + "#calculate the number of turns\n", + "# given :\n", + "e1=2200.;#voltage in volts\n", + "f=50.;#frequency in Hz\n", + "e2=220.;#voltage in volts\n", + "fd=1.6;#magnetic field in Tesla\n", + "a=3600.;#area in mm**2\n", + "#calculations\n", + "n1=(e1/(4.44*f*fd*a*10**-6));#number of turns\n", + "n2=(e2/(4.44*f*fd*a*10**-6));#number of turns\n", + "#results\n", + "print \"number of primary winding turns are\",round(n1)\n", + "print \"number of secondary winding turns are\",round(n2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2 : pg 68" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + "iron loss current is, (A)= 0.182\n", + "magnetising component is, (A)= 0.572\n", + " part (b)\n", + "iron loss current is, (A)= 0.1\n", + "magnetising component is, (A)= 0.49\n" + ] + } + ], + "source": [ + "# Example 4.2;\n", + "#calculate the components of no load currents,magnetising and working components of exciting current \n", + "from math import sqrt\n", + "# given \n", + "print \"part (a)\"\n", + "nlw=2000.;#no load input watts\n", + "pv=11000.;#primary voltage\n", + "#calculations and results\n", + "Iw=nlw/pv;#current in amperes\n", + "Io=0.6;#current in amperes\n", + "Imu=sqrt(Io**2-Iw**2);#current in amperes\n", + "print \"iron loss current is, (A)=\",round(Iw,3)\n", + "print \"magnetising component is, (A)=\",round(Imu,3)\n", + "pf=0.2;#power factpr\n", + "Io=0.5;#current in amperes\n", + "Iw=Io*(pf);#current in amperes\n", + "Imu=Io*sqrt(1-pf**2);#magnetising component in amperes\n", + "print \" part (b)\"\n", + "print \"iron loss current is, (A)=\",Iw\n", + "print \"magnetising component is, (A)=\",round(Imu,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3 : pg 68" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current is, (A)= 33.43\n" + ] + } + ], + "source": [ + "# Example 4.3;current\n", + "#calculate the current\n", + "from math import sqrt, acos, cos\n", + "# given \n", + "pf1=0.866;#power factor\n", + "pf2=0.1736;#power factor\n", + "#calculations\n", + "ph1=acos(pf1);#phase angle in radians\n", + "ph2=acos(pf2);#phase angle in radians\n", + "ir=120.;#current in amperes\n", + "n2=110;#number of turns\n", + "n1=440.;#number of turns\n", + "i2d=(n2/n1)*ir;#current in amperes\n", + "io=5.;#current in amperes\n", + "aioi2=ph2-ph1;#change in angle in degree\n", + "i1=sqrt(io**2+i2d**2+(2*io*i2d*cos(aioi2)));#current in amperes\n", + "#results\n", + "print \"current is, (A)=\",round(i1,2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4 : pg 69" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total core losses is,(W) = 2900.0\n" + ] + } + ], + "source": [ + "# Example 4.4;core losses\n", + "#calculate the core losses\n", + "# given \n", + "f=50.;#frquency in Hz\n", + "hl=650.;#hystresis loss\n", + "edl=400.;#eddy current loss\n", + "#calculations\n", + "A=hl/f;#parameter\n", + "B=edl/f**2;#parameter\n", + "Ph=A*2*f;#loss in watts\n", + "Pe=B*(2*f)**2;#loss in watts\n", + "pt=Ph+Pe;#total loss in watts\n", + "#results\n", + "print \"total core losses is,(W) = \",pt\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5 : pg 71" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + "full load efficiency at 0.8 pf is,(%)= 96.165\n", + "part (b)\n", + "percentage of full load on which efficiency will be maximum is,(%)= 95.603\n" + ] + } + ], + "source": [ + "# Example 4.5;\n", + "#calculate the efficiency and load for maximum efficiency \n", + "from math import sqrt\n", + "# given \n", + "cl=125.;#copper losses\n", + "fcl=2**2*cl;#full load copper losses\n", + "il=457.;#iron losses\n", + "pf=0.8;#power factor\n", + "kba=30.;#loss\n", + "#calculations and results\n", + "print \"part (a)\"\n", + "fle=((kba*pf)/((kba*pf)+(fcl+il)*10**-3))*100;#full load efficiency in %\n", + "print \"full load efficiency at 0.8 pf is,(%)=\",round(fle,3)\n", + "lme=kba*sqrt(il/fcl);#variable\n", + "pfl=(lme/kba)*100;#percentage of full load on which efficiency will be maximum \n", + "print \"part (b)\"\n", + "print \"percentage of full load on which efficiency will be maximum is,(%)=\",round(pfl,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6 : pg 73" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "all day efficiency is,(%)= 95.31\n" + ] + } + ], + "source": [ + "# Example 4.6;\n", + "#calculate the all day efficiency \n", + "#given\n", + "ef=0.98;#efficiency in %\n", + "kva=15;#kVA\n", + "pf=1;#power factor\n", + "#calculations\n", + "op=kva*pf;#output power in kW\n", + "ip=op/ef;#input power in kW\n", + "loss=ip-op;#loss in kW\n", + "cl=(loss*10**3)/2;#copper loss in W\n", + "il=cl;#iron loss in W\n", + "t1=12;#time in hours\n", + "p1=2;#power in kW\n", + "pf1=0.5;#power factor\n", + "y1=(p1)/pf1;#kVA\n", + "il1=il*t1;#loss in Wh\n", + "cl1=cl*((y1)/kva)**2*t1;#copper loss in Wh\n", + "top1=p1*t1;#kWht1=12;#time in hours\n", + "t2=6;#time in hours\n", + "p2=12;#power in kW\n", + "pf2=0.8;#power factor\n", + "y2=(p2)/pf2;#kVA\n", + "il2=il*t2;#iron loss in Wh\n", + "cl2=cl*((y2/kva)**2)*t2;#copper loss in Wh\n", + "top2=p2*t2;#kWh\n", + "t3=6;#time in hours\n", + "il3=il*t3;#iron loss Wh\n", + "tol=top1+top2;#iron loss kWh\n", + "til=(il1+il2+il3)*10**-3;#total iron loss in kWh\n", + "tcl=(cl1+cl2)*10**-3;#total copper loss in kWh\n", + "ade=((tol)/(tol+til+tcl))*100;#efficiency in %\n", + "#results\n", + "print \"all day efficiency is,(%)=\",round(ade,2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7 : pg 75" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iron losses is,(kW)= 2.32\n" + ] + } + ], + "source": [ + "# Example 4.7;iron losses\n", + "#calculate the iron losses\n", + "from math import sqrt\n", + "#given\n", + "kva=200;#kVA\n", + "pf=0.8;#power factor\n", + "rflo=kva*pf;#kW\n", + "ef=0.96;#efficiency\n", + "#calculations\n", + "ip=rflo/ef;#kW\n", + "tl=ip-rflo;#kW\n", + "e2=800;#volts\n", + "e1=6600;#volts\n", + "n21=((e2/sqrt(3))/e1);#turn ratiom\n", + "r1=4;#ohms\n", + "r2=0.05;#ohms\n", + "roe=(r1)*n21**2+r2;#ohms\n", + "fli=((kva*10**3)/(sqrt(3)*e2));#amperes\n", + "fcl=3*fli**2*roe;#kW\n", + "il=tl-(fcl)*10**-3;#kW\n", + "#results\n", + "print \"iron losses is,(kW)=\",round(il,2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8 : pg 78" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a) \n", + "equivalent resistance referred to the primary is,(Ohm)= 7.05\n", + "equivalent reactance referred to the primary is,(Ohm)= 11.2\n", + "equivalent resistance referred to the secondary is,(Ohm)= 0.017625\n", + "equivalent reactance referred to the secondary is,(Ohm)= 0.028\n", + "equivalent impedance referred to the primary is,(Ohm)= 13.234\n", + "equivalent impedance referred to the secondary is,(Ohm)= 0.033\n", + "part (b) \n", + "total copper losses considering individual resistance is,(W)= 910.382\n", + "total copper losses consdering equivalent resistance (for primary) is,(W)= 910.382\n", + "total copper losses consdering equivalent resistance (for secondary) is,(W)= 910.382\n" + ] + } + ], + "source": [ + "# Example 4.8;\n", + "#calculate the resistance,reactances and impedances and copper losses\n", + "from math import sqrt \n", + "#given\n", + "r1=3.45;#ohms\n", + "r2=0.009;#ohms\n", + "x1=5.2;#ohms\n", + "x2=0.015;#ohms\n", + "kva=100.;#kVA\n", + "e1=8800.;#volts\n", + "e2=440.;#volts\n", + "#calculations\n", + "i1=(kva*10**3)/e1;#in amperes\n", + "i2=(kva*10**3)/e2;#in amperes\n", + "k=e2/e1;#transformation ratio\n", + "ro1=r1+(r2/k**2);#ohms\n", + "xo1=x1+(x2/k**2);#ohms\n", + "ro2=r2+(k**2*r1);#ohms\n", + "xo2=k**2*xo1;#ohms\n", + "zo1=sqrt(ro1**2+xo1**2);#ohms\n", + "zo2=sqrt(ro2**2+xo2**2);#ohms\n", + "tcl=i1**2*r1+i2**2*r2;#in watts\n", + "tcl1=i1**2*ro1;#in watts\n", + "tcl2=i2**2*ro2;#in watts\n", + "#results\n", + "print \"part (a) \"\n", + "print \"equivalent resistance referred to the primary is,(Ohm)=\",ro1\n", + "print \"equivalent reactance referred to the primary is,(Ohm)=\",xo1\n", + "print \"equivalent resistance referred to the secondary is,(Ohm)=\",ro2\n", + "print \"equivalent reactance referred to the secondary is,(Ohm)=\",xo2\n", + "print \"equivalent impedance referred to the primary is,(Ohm)=\",round(zo1,3)\n", + "print \"equivalent impedance referred to the secondary is,(Ohm)=\",round(zo2,3)\n", + "print \"part (b) \"\n", + "print \"total copper losses considering individual resistance is,(W)=\",round(tcl,3)\n", + "print \"total copper losses consdering equivalent resistance (for primary) is,(W)=\",round(tcl1,3)\n", + "print \"total copper losses consdering equivalent resistance (for secondary) is,(W)=\",round(tcl2,3)\n", + "#copper losses are calculated wrong in the textbook\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9 : pg 82" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " part (a)\n", + "magnetising component of no load current (Im) is,(A)= 0.87\n", + "working component of no load current (Iw) is,(A)= 0.5\n", + "resistance for primary side (Rm) is,(Ohm)= 400.0\n", + "reactance for primary ohms (Xm) is,(Ohm)= 230.94\n", + "impedence for primary side (X01) is,(Ohm)= 0.31\n", + "part (b)\n", + "percentage regulation on lagging load is,(%)= 3.55\n", + "percentage regulation on leading load is,(%)= -0.15\n", + "part (c)\n", + "efficiency at full load is,(%)= 94.53\n", + "efficiency at half load is,(%)= 92.96\n" + ] + } + ], + "source": [ + "# Example 4.9;\n", + "#calculate the parameter of primary side ,regulation and efficiency\n", + "from math import sqrt\n", + "#given\n", + "po=100.;#watts\n", + "v1=200.;#volts\n", + "io=1;#amperes\n", + "#calculations and results\n", + "ocpf=po/(v1*io);#open circuit power factor\n", + "sinpf=sqrt(1-ocpf**2);#\n", + "im=io*sinpf;#in amperes\n", + "iw=io*ocpf;#current in amperes\n", + "rm=v1/iw;#ohms\n", + "xm=v1/im;#in ohms\n", + "vs=15.;#volts\n", + "ia=10.;#amperes\n", + "zo2=vs/ia;#in ohms\n", + "wa=85.;#watts\n", + "ro2=wa/(ia)**2;#ohms\n", + "e2=400.;#volts\n", + "e1=200.;#volts\n", + "k=e2/e1;#transformation ratio\n", + "zo1=zo2/k**2;#ohms\n", + "ro1=ro2/k**2;#ohms\n", + "xo1=sqrt(zo1**2-ro1**2);#ohms\n", + "print \" part (a)\"\n", + "print \"magnetising component of no load current (Im) is,(A)=\",round(im,2)\n", + "print \"working component of no load current (Iw) is,(A)=\",iw\n", + "print \"resistance for primary side (Rm) is,(Ohm)=\",round(rm,2)\n", + "print \"reactance for primary ohms (Xm) is,(Ohm)=\",round(xm,2)\n", + "print \"impedence for primary side (X01) is,(Ohm)=\",round(xo1,2)\n", + "print \"part (b)\"\n", + "kva=4000;#kVA\n", + "i2=kva/e2;#in amperes\n", + "xo2=sqrt(zo2**2-ro2**2);#ohms\n", + "pf=0.8;# power factor\n", + "vlag=i2*(ro2*pf+xo2*sqrt(1-pf**2));#in volts\n", + "prld=(vlag*po)/e2;#\n", + "vlag1=i2*(ro2*pf-xo2*sqrt(1-pf**2));#in volts\n", + "prld1=(vlag1*po)/e2;#\n", + "print \"percentage regulation on lagging load is,(%)=\",round(prld,2)\n", + "print \"percentage regulation on leading load is,(%)=\",round(prld1,2)\n", + "print \"part (c)\"\n", + "cl=85;#copper losses\n", + "nloss=100;#no load losses\n", + "fll=cl+nloss;#full load losses\n", + "pf=0.8;#power factor\n", + "flo=kva*pf;#efficiency \n", + "effl=flo/(flo+fll);#efficiency \n", + "hll=(1./2)**2*cl+nloss;#loss in watts\n", + "op=(1./2)*kva*pf;#ouput power in watts\n", + "efhl=op/(hll+op);#efficiency at half load\n", + "print \"efficiency at full load is,(%)=\",round(effl*100,2)\n", + "print \"efficiency at half load is,(%)=\", round(efhl*100,2)\n" + ] + } + ], + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter5.ipynb b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter5.ipynb new file mode 100644 index 00000000..194573ff --- /dev/null +++ b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter5.ipynb @@ -0,0 +1,571 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 5 : Electrical Measurements" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1 : pg 81" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "required resistance is,(ohm)= 15000.0\n" + ] + } + ], + "source": [ + "# Example 5.1 : resistance\n", + "#calculate the resistance \n", + "# given :\n", + "n=50.;#number of turns\n", + "B=1.;#magnetic field in tesla\n", + "I=1.;#current in amperes\n", + "L=4.;#length in cm\n", + "d=3.;#dia in cm\n", + "#calculations\n", + "Td=n*B*I*L*d*10**-4;#torque in N-m\n", + "cd1=2.4*10**-4;#controlling torque\n", + "id=cd1/Td;#current in amperes\n", + "fsv=100;#full scale voltage\n", + "trv=fsv/id;#ohms\n", + "adr=10000;#ohms\n", + "r=trv-adr;#ohms\n", + "#results\n", + "print \"required resistance is,(ohm)=\",r\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2 : pg 82" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total resistance of the voltmeter is,(ohm)= 49990.0\n" + ] + } + ], + "source": [ + "# Example 5.2 : resistance\n", + "#calculate the total resistance \n", + "# given :\n", + "fsf=20.;#full scale deflection current in mA\n", + "v=200.;#voltage in mV\n", + "#calculations\n", + "ri=v/fsf;#resistance in ohms\n", + "x=199.98;#current in amperes\n", + "rsh=(v*10**-3)/x;#ohms\n", + "fs2=1000;#volts\n", + "trv=fs2/(fsf*10**-3);#ohms\n", + "rse=trv-ri;#reqquired resistance in ohms\n", + "#results\n", + "print \"total resistance of the voltmeter is,(ohm)=\",rse\n", + "#in the text book approximately value of resistance is taken as 50000 ohm\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3 : pg 82" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + "power factor is ,= 0.693\n", + "part (b)\n", + "power factor is ,= 0.327\n" + ] + } + ], + "source": [ + "# Example 5.3 : power factor\n", + "#calculate the power factor\n", + "from math import sqrt, atan, cos\n", + "# given :\n", + "w1=2000.;#power in watts\n", + "w2=500.;#power in watts\n", + "#calculations and results\n", + "an=atan(sqrt(3)*(((w1-w2)/(w1+w2))));#angle in radians\n", + "print \"part (a)\"\n", + "pf=cos(an);#power factor\n", + "print \"power factor is ,=\",round(pf,3)\n", + "print \"part (b)\"\n", + "w1=2000.;#power in watts\n", + "w2=-500.;#power in watts\n", + "an=atan(sqrt(3)*(((w1-w2)/(w1+w2))));#angle in degree\n", + "pf=cos(an);#power factor\n", + "print \"power factor is ,=\",round(pf,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4 : pg 83" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (i)\n", + "indication of moving iron instrument is,(A)= 5.64\n", + "part (ii)\n", + "indication of moving coil instrument is,(A)= 3.18\n" + ] + } + ], + "source": [ + "# Example 5.4;reading\n", + "#calculate the reading of the instrument\n", + "from math import sqrt, pi, sin\n", + "from scipy import integrate\n", + "import numpy\n", + "print \"part (i)\"\n", + "# given :\n", + "vm=100.;#volts\n", + "rc=10.;#ohms\n", + "#calculations and results\n", + "im=vm/rc;#amperes\n", + "t= numpy.linspace(0,2*pi, num =3);#time rane\n", + "#x=intsplin(t,(sin(t))**2);#variable\n", + "x=2.0;\n", + "Irms=sqrt((1/(2*pi))*im**2*x);#current in amperes\n", + "print \"indication of moving iron instrument is,(A)=\",round(Irms,2)\n", + "print \"part (ii)\"\n", + "t1=0;#time interval\n", + "t2=pi;#time inerval\n", + "def function(t):\n", + " return sin(t)\n", + " \n", + "x=integrate.quad(function,t1,t2)[0];#variable\n", + "Iav=(1/pi)*x*(im/2);#current in amperes\n", + "print \"indication of moving coil instrument is,(A)=\",round(Iav,2)\n", + "#answer of part a is calculated wrong in the textbook\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5 : pg 86" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current read by meter 1 is,(A)= 55.56\n", + "current read by meter 2 is,(A)= 44.44\n" + ] + } + ], + "source": [ + "# Example 5.5;reading\n", + "#calculate the current reading\n", + "# given :\n", + "fsd=100.;#full scale division in amperes\n", + "fsd1=100.;#full scale division in mA\n", + "#calculations\n", + "csh=fsd-(fsd*10**-3);#difference in currents in amperes\n", + "rx=0.8;#resistance in ohms\n", + "r1=((fsd1*10**-3*rx)/csh);#resistance in ohms\n", + "rx1=1;#resistance in ohms\n", + "r2=((fsd1*10**-3*rx1)/csh);#resistance in ohms\n", + "em1=((rx*r1)/(rx+r1));#resistance in ohms\n", + "em2=((rx1*r2)/(rx1+r2));#resistance in ohms\n", + "crm1=((em2*10**4*fsd)/((em2*10**4)+(em1*10**4)));#current in amperes\n", + "crm2=((em1*10**4*fsd)/((em1*10**4)+(em2*10**4)));#current in amperes\n", + "#results\n", + "print \"current read by meter 1 is,(A)=\",round(crm1,2)\n", + "print \"current read by meter 2 is,(A)=\",round(crm2,2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6 : pg 90" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + "multiplier resistance Rs is,(Ohm)= 1825.0\n", + "part (b)\n", + "sensivity is,(Ohm/V)= 225.0\n" + ] + } + ], + "source": [ + "# Example 5.6;\n", + "#calculate the multiplier resistance and sensivity\n", + "# given :\n", + "rm=50.;#resistance in ohms\n", + "rsh=rm;#shunt resistance in ohms\n", + "it=2.;#current in mA\n", + "erms=10.;#rms voltage in volts\n", + "#calculations\n", + "ede=0.45*erms;#voltage in volts\n", + "rd1=400.;#resistance in ohms\n", + "x=(rm*rsh)/(rm+rsh);#resistance in ohms\n", + "r1=ede/(it*10**-3);#resistance in ohms\n", + "rs=r1-x-rd1;#resistance in ohms\n", + "S=r1/erms;#sensivity in ohms/V\n", + "#results\n", + "print \"part (a)\"\n", + "print \"multiplier resistance Rs is,(Ohm)=\",rs\n", + "print \"part (b)\"\n", + "print \"sensivity is,(Ohm/V)=\",S\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7 : pg 91" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + "apparent resistance of unknown resistor is,(kilo-Ohm)= 40.0\n", + "part (b)\n", + "actual resistance of unknown resistor is,(kilo-Ohm)= 47.619\n", + "part (c)\n", + "percentage error is,(%)= 16.0\n" + ] + } + ], + "source": [ + "# Example 5.7;\n", + "#calculate the apparent resistance of the unknown resistor,actual resistance of the unknown resistor and percentage error\n", + "# given :\n", + "v=200.;#voltage in volts\n", + "i=5.;#current in mA\n", + "#calculations and results\n", + "tr=v/i;#resistance in kilo ohms\n", + "print \"part (a)\"\n", + "print \"apparent resistance of unknown resistor is,(kilo-Ohm)=\",tr\n", + "S=1000.;#sensivity in ohms/V\n", + "V1=250.;#voltage in volts\n", + "rv=V1*S*10**-3;#resistance in kilo ohms\n", + "rx=(V1*tr)/(V1-tr);#resistance in kilo ohms\n", + "print \"part (b)\"\n", + "print \"actual resistance of unknown resistor is,(kilo-Ohm)=\",round(rx,3)\n", + "per=(rx-tr)/rx;#percentage error\n", + "print \"part (c)\"\n", + "print \"percentage error is,(%)=\",per*100\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8 : pg 92" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "resolution is, (V)= 0.2\n" + ] + } + ], + "source": [ + "# Example 5.8;resolution\n", + "#calculate the resolution\n", + "# given :\n", + "fsr=200.;#full scale reading in volts\n", + "d=100.;#number of divisions\n", + "sc=1/10.;#scale\n", + "#calculations\n", + "sd1=fsr/d;#one sccale divisions\n", + "R=sc*sd1;#resolution\n", + "#results\n", + "print \"resolution is, (V)=\",R\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9 : pg 93" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "resolution is ,(mV)= 1.0\n" + ] + } + ], + "source": [ + "# Example 5.9;resolution\n", + "#calculate the resolution\n", + "# given :\n", + "fsr=9.999;#full scale reading in volts\n", + "d=9999.;#number of divisions\n", + "#calculations\n", + "R=(1/d)*fsr*10**3;#resolution\n", + "#results\n", + "print \"resolution is ,(mV)=\",R\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10 : pg 95" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (i)\n", + "true value of resistance is,(Ohm)= 91.65\n", + "part (ii)\n", + "percentage error is,(%)= 1.8\n", + "part (iii)\n", + "reading of voltmeter is,(V)= 18.35\n" + ] + } + ], + "source": [ + "# Example 5.10;\n", + "#calculate the true resistance of the unknown resistor , percentage error and reading voltmeter\n", + "# given :\n", + "print \"part (i)\"\n", + "ra=0.1;#ohms\n", + "vr=18.;#voltage in volts\n", + "am=0.2;#current in amperes\n", + "#calculations and results\n", + "apr=vr/am;#in ohms\n", + "rv=5000.;#ohms\n", + "im=vr/rv;#amperes\n", + "rxi=am-(im);#in amperes\n", + "rx=vr/rxi;#ohms\n", + "print \"true value of resistance is,(Ohm)=\",round(rx,3)\n", + "per=((rx-apr)/rx)*100;#percentage error\n", + "print \"part (ii)\"\n", + "print \"percentage error is,(%)=\",per\n", + "rvv=am*(ra+rx);#reading of voltmeter\n", + "print \"part (iii)\"\n", + "print \"reading of voltmeter is,(V)=\",round(rvv,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11 : pg 96" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (i)\n", + "resistance of shunt (range 0-100mA) Rsh1 is,(Ohm)= 5.556\n", + "part (ii)\n", + "resistance of shunt (range 0-500mA) Rsh2 is,(Ohm)= 1.02\n", + "part (iii)\n", + "resistance of shunt (range 0-1A) Rsh2 is,(Ohm)= 0.505\n", + "part (iv)\n", + "resistance of shunt (range 0-5A) Rsh2 is,(Ohm)= 0.1\n" + ] + } + ], + "source": [ + "# Example 5.11;resistance\n", + "#calculate the resistance in all cases\n", + "# given :\n", + "im=10.;#mA\n", + "i=100.;#mA\n", + "#calculations and results\n", + "m=i/im;#multiplying factor\n", + "rm=50;#ohms\n", + "rsh=rm/(m-1);#in ohms\n", + "print \"part (i)\"\n", + "print \"resistance of shunt (range 0-100mA) Rsh1 is,(Ohm)=\",round(rsh,3)\n", + "i1=500.;#mA\n", + "m1=i1/im;#multiplying factor\n", + "rm1=50.;#ohms\n", + "rsh1=rm1/(m1-1);#in ohms\n", + "print \"part (ii)\"\n", + "print \"resistance of shunt (range 0-500mA) Rsh2 is,(Ohm)=\",round(rsh1,3)\n", + "im2=1;#A\n", + "i2=100.;#A\n", + "m2=i2/im2;#multiplying factor\n", + "rm2=50.;#ohms\n", + "rsh2=rm2/(m2-1);#in ohms\n", + "print \"part (iii)\"\n", + "print \"resistance of shunt (range 0-1A) Rsh2 is,(Ohm)=\",round(rsh2,3)\n", + "im3=1;#A\n", + "i3=500.;#A\n", + "m3=i3/im3;#multiplying factor\n", + "rm3=50.;#ohms\n", + "rsh3=rm3/(m3-1);#in ohms\n", + "print \"part (iv)\"\n", + "print \"resistance of shunt (range 0-5A) Rsh2 is,(Ohm)=\",round(rsh3,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12 : pg 98" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "load power is,(kW)= 1.5\n" + ] + } + ], + "source": [ + "# Example 5.12;load power\n", + "#calculate the load power\n", + "# given :\n", + "k=600.;#in rev./kwh.\n", + "nr=5.;#number of revolutions\n", + "t=20.;#time in seconds\n", + "#calculations\n", + "lp=(1/k)*nr*((60*60)/t);#power in kW\n", + "#results\n", + "print \"load power is,(kW)=\",lp\n" + ] + } + ], + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter6.ipynb b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter6.ipynb new file mode 100644 index 00000000..3af7cbe5 --- /dev/null +++ b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter6.ipynb @@ -0,0 +1,643 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 6 : Rotating electrical machine" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1 : pg 105" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Terminal voltage,(V) = 459.25\n" + ] + } + ], + "source": [ + "#Example 6.1# Terminal voltage \n", + "#calculate the terminal voltage\n", + "#given data :\n", + "Z=440.;# number of lap\n", + "N=900.;# revolutions in rpm\n", + "fi=0.07;#fluxin Wb\n", + "P=4.;# number of pole\n", + "A=4.;#constant\n", + "Ia=50.;# armature current in Amperes\n", + "E=462.;#voltage in V\n", + "#calculations\n", + "E=(P*fi*Z*N)/(60*A);#general voltage in volts\n", + "R=0.002;# resistance in ohm\n", + "C=110.;# conductors\n", + "Re=C*R;#resistance of each path in ohm\n", + "Ra=Re/A;#armature resistance in ohm\n", + "V=E-(Ia*Ra);#terminal voltage in volts\n", + "#results\n", + "print \"Terminal voltage,(V) = \",V" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2 : pg 105" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "emf when machine acts as generator,(V) = 205.0\n", + "emf when machine acts as motor,(V) = 195.0\n" + ] + } + ], + "source": [ + "#Example 6.2# e.m.f \n", + "#calculate the emf in all cases\n", + "#given data :\n", + "V=200.;#voltage\n", + "Ra=0.1;#resistance in ohm\n", + "Ia=50.;#armature current in Amperes\n", + "#calculations\n", + "E=V+(Ia*Ra);#generator voltage in volts\n", + "Eb=V-(Ia*Ra);#motor voltage in volts\n", + "#results\n", + "print \"emf when machine acts as generator,(V) = \",E\n", + "print \"emf when machine acts as motor,(V) = \",Eb\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3 : pg 106" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "speed is,(rpm)= 623.944\n", + "armature torque is, (N-m)= 323.76\n", + "full load motor efficiency is ,(%)= 79.2\n" + ] + } + ], + "source": [ + "#Example 6.3\n", + "#calculate the speed ,torque and efficiency\n", + "v=200.;#voltage in volts\n", + "r=100.;#resistance in ohms\n", + "#calculations\n", + "ish=v/r;#shunt current in amperes\n", + "i=4;#current in amperes\n", + "nla=i-ish;#no load armature current in amperes\n", + "w=8.;#powerin kW\n", + "ifl=(w*10**3)/v;#full load current in amperes\n", + "fla=ifl-ish;#full load armature current in amperes\n", + "r1=0.6;#internal resistance in ohms\n", + "ebo=(v-(ish*r1));#voltage in volts\n", + "eb=(v-(fla*r1));#voltage in volts\n", + "no=700.;#number of rpm\n", + "n=no*(eb/ebo);#number of rpm\n", + "ta=((eb*fla*60)/(2*n));#armature torque in N-m\n", + "nlpi=v*i;#no load power input in watts\n", + "cl=(ish**2*r1);#copper losses in watts\n", + "cl=nlpi-cl;#total copper lossses in Watts\n", + "flacl=(fla**2*r1);#full load armmature copper losses in Watts\n", + "tfll=flacl+cl;#total full load losses in Watts\n", + "flo=(w*10**3)-tfll;#full load output in Watts\n", + "ef=((flo)/(w*10**3))*100;#efficiency\n", + "#results\n", + "print \"speed is,(rpm)=\",round(n,3)\n", + "print \"armature torque is, (N-m)=\",ta\n", + "print \"full load motor efficiency is ,(%)=\",ef\n", + "#armature torque is calculated wrong in the textbook\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4 : pg 108" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The speed of the machine,(rpm) = 1003.51\n" + ] + } + ], + "source": [ + "#Example 6.4# speed\n", + "#calculate the speed of the machine\n", + "#given data :\n", + "fi=0.02# flux in Wb\n", + "P=4.;# number of poles\n", + "A=2.;#constant\n", + "Z=151.*A;#turns\n", + "V=200.;# in volts\n", + "Rsh=50.;#shunt resistance in ohm\n", + "Ra=0.01;# armature resistance in ohm\n", + "Pr=40000.;#power required in Watts\n", + "#calculations\n", + "Il=Pr/V;#load current in amperes\n", + "Ish=V/Rsh;#shunt current in amperes\n", + "Ia=Il+Ish;#armature current in amperes\n", + "E=V+(Ia*Ra);#generated voltage\n", + "N=(60*A*E)/(fi*P*Z);#rpm\n", + "#results\n", + "print \"The speed of the machine,(rpm) = \",round(N,3)\n", + "#answer is wrong in the textbook\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5 : pg 112" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Power consumed is,(W)= 5154.127\n" + ] + } + ], + "source": [ + "#Example 6.5# Power\n", + "#calculate the power consumed\n", + "#given data :\n", + "fp=0.024;# flux per pole\n", + "lf=1.2;# leakage factor\n", + "fi=fp/lf;# in Wb\n", + "Z=756;#turns\n", + "P=4;# number of pole\n", + "N=1000;# in rpm\n", + "A=4;#constant\n", + "#calculations\n", + "E=(fi*Z*N*P)/(60*A);#generated voltage\n", + "il=1/10.;#load current in amperes\n", + "ish=1/100.;#shunt current in amperes\n", + "ra=1;#armature resistance in ohms\n", + "isa=il+ish;#current in amperes\n", + "v=((E)/(1+(ra*isa)));#volts\n", + "r2=10;#ohms\n", + "il=v/r2;#amperes\n", + "pc=il*v;#Watts\n", + "#results\n", + "print \"Power consumed is,(W)=\",round(pc,3)\n", + "#answer is wrong in the textbook\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6 : pg 115" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + "emf genereted,(V) = 254.0\n", + "part (b)\n", + "Total copper losses,(kW) = 3.3\n", + "Output of the prime mover,(W) = 51750.0\n", + "part (c)\n", + "Mechanical efficiency,(%) = 98.164\n", + "Electrical efficiency,(%) = 93.504\n", + "Commercial efficiency,(%) = 91.787\n" + ] + } + ], + "source": [ + "#Example 6.6: \n", + "#calculate the e.m.f ,copper losses ,output of the prime mover ,commercial, mechanical and electrical efficiencies\n", + "#given data :\n", + "Il=190;#load current in Amperes\n", + "V=250;# voltage in volts\n", + "Ra=0.02;#armature resistance in ohm\n", + "Rsh=25.;#shunt resistance in ohm\n", + "#calculations and results\n", + "Ish=V/Rsh;#shunt current in amperes\n", + "Ia=Ish+Il;#armature current in amperes\n", + "E=V+(Ia*Ra);#generated voltage\n", + "print \"part (a)\"\n", + "print \"emf genereted,(V) = \",E\n", + "Cl=(Ia**2*Ra);# armeture copper losses\n", + "Sl=Ish*V;# shunt copper losses\n", + "T=(Cl+Sl)*10**-3;#copper losses in k-Watt\n", + "print \"part (b)\"\n", + "print \"Total copper losses,(kW) = \",T\n", + "Eo=V*Il;#output voltage in volts\n", + "I_l=950.;#iron loss in watt\n", + "O=Eo+I_l+(T*10**3);#output in watt\n", + "print \"Output of the prime mover,(W) = \",O\n", + "Ep=O-I_l;# electrical power in W\n", + "Me=(Ep/O)*100;#Mechanical efficiency\n", + "print \"part (c)\"\n", + "print \"Mechanical efficiency,(%) = \",round(Me,3)\n", + "Ee=(Eo/Ep)*100;#Electrical efficiency\n", + "print \"Electrical efficiency,(%) = \",round(Ee,3)\n", + "Ce=(Eo/O)*100;#Commercial efficiency\n", + "print \"Commercial efficiency,(%) = \",round(Ce,3)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7 : pg 117" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "additional resistance required is,(Ohm)= 9.162\n" + ] + } + ], + "source": [ + "#Example 6.7# resistance \n", + "#calculate the resistance\n", + "#given:\n", + "n=1000;#turns in rpm\n", + "ra=0.3;#armature resistance in ohms\n", + "rf=40;#field resistance in ohms\n", + "it=5;#field current in amperes\n", + "if1=4;#field current in amperes\n", + "e1=220.;#emf in volts\n", + "e2=200.;#emf in volts\n", + "ia=35.;#armature current in amperes\n", + "#calculations\n", + "eb=(e1-(ia*ra));#emf in volts\n", + "x=((eb-e2)/(it*if1));#additional field current in amperes\n", + "ce=e1-e2;#change in emf in volts\n", + "ix=if1+x;#total current in amperes\n", + "rt=(e1/ix);#total resistance in ohms\n", + "adr=rt-rf;#additional resistance required in ohms\n", + "#results\n", + "print \"additional resistance required is,(Ohm)=\",round(adr,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8 : pg 120" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + "resistance to be added is,(Ohm)= 18.644\n", + "part (b)\n", + "resistance to be added is,(Ohm)= 1.519\n", + "speed is,(rpm)= 1500.0\n" + ] + } + ], + "source": [ + "#Example 6.8# resistance and speed\n", + "#calculate the resistance and speed\n", + "from math import ceil\n", + "#given:\n", + "v1=240.;#primary voltage\n", + "r1=0.2;#primary resistance in ohm\n", + "i1=40.;#primary current in volts\n", + "#calculations and results\n", + "eb1=(v1-i1*r1);#primary emf\n", + "n11=1800.;#number of turns on primary side in rpm\n", + "n21=1600.;#number of turns on secondary side in rpm\n", + "i2=10.;#secondary current in amperes\n", + "x=((n21/n11)*(i2/i1)*eb1);#variable\n", + "r=((v1-(i2*r1))-x)/i2;#resistance in ohm\n", + "print \"part (a)\"\n", + "print \"resistance to be added is,(Ohm)=\",round(r,3)\n", + "print \"part (b)\"\n", + "n11=1800.;#number of turns on primary side\n", + "n21=900.;#number of turns on secondary side in rpm\n", + "i2=60.;#secondary current in amperes\n", + "x=((n21/n11)*(1.18)*eb1);#variable\n", + "r=((v1-(i2*r1))-x)/i2;#resistance in ohms\n", + "print \"resistance to be added is,(Ohm)=\",round(r,3)\n", + "eb2=228.;#secondary emf in volts\n", + "eb1=232.;#primary emf in volts\n", + "p1=100.;#primary power in watt\n", + "p2=118.;#secondary power in watt\n", + "n2=((eb2/eb1)*(p1/p2)*n11);#speed in rpm\n", + "print \"speed is,(rpm)=\",ceil(n2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9 : pg 121" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "speed is,(rpm)= 1433.938\n" + ] + } + ], + "source": [ + "#Example 6.9# speed\n", + "#calculate the speed\n", + "from math import sqrt\n", + "#given:\n", + "i1=50.;#primary current in amperes\n", + "i2=i1/(sqrt(2));#secondary current in amperes\n", + "r1=0.2;#primary resistance in ohms\n", + "v1=220.;#primary voltage in volts\n", + "#calculations\n", + "eb1=((v1-(i1*r1)));#primary emf in volts\n", + "eb2=((v1-(i2*r1)));#secondary emf in volts\n", + "n1=1000#primary speed in rpm\n", + "n2=(n1*(eb2/eb1)*(i1/i2));#seconadry speed in rpm\n", + "#results\n", + "print \"speed is,(rpm)=\",round(n2,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10 : pg 124" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + " The speed of rotating magnetic field,(rpm) = 1500.0\n", + "part (b)\n", + "Motor speed,(rpm) = 1447.5\n", + "part (c)\n", + "Frequency 2.0 Hz or 120 rpm \n", + "part (d)\n", + "Frequency of rotor current,(Hz) = 50.0\n" + ] + } + ], + "source": [ + "#Example 6.10# \n", + "#calculate the Speed ,motor speed,and frequency \n", + "#given data :\n", + "print \"part (a)\"\n", + "f=50.;#frquency in Hz\n", + "P=4;# number of pole\n", + "#calculations and results\n", + "Ns=(120*f)/P;#speed in rom\n", + "print \" The speed of rotating magnetic field,(rpm) = \",Ns\n", + "print \"part (b)\"\n", + "S=0.035;# slip\n", + "N=Ns*(1-S);#motor speed in rpm\n", + "print \"Motor speed,(rpm) = \",N\n", + "print \"part (c)\"\n", + "S=0.04;# slip\n", + "F=S*f;#frequency in Hz\n", + "print \"Frequency \",F,\" Hz or \",120,\" rpm \"\n", + "print \"part (d)\"\n", + "f=50.;# in Hz\n", + "F=f;#frequency in Hz\n", + "print \"Frequency of rotor current,(Hz) = \",F\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11 : pg 125" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a)\n", + "rotor current per phase is,(A)= 14.003\n", + "power factor is,= 0.243\n", + "part (b)\n", + "rotor current per phase is,(A)= 10.206\n", + "power factor is,= 0.707\n" + ] + } + ], + "source": [ + "#Example 6.11# \n", + "#calculate the current per phase and power factor\n", + "from math import sqrt\n", + "#given:\n", + "v1=100.;#emf in volts\n", + "vi=v1/sqrt(3);#induced emf in volts\n", + "r1=1.;#rotor resistance ohms per phase\n", + "r2=4.;#rotor reactance ohms per phase\n", + "#calculations and results\n", + "r=sqrt(r1**2+r2**2);#rotor impedence per phase\n", + "rcp=(vi/r);#rotor current per phase\n", + "pf=(1./r);#power factor\n", + "print \"part (a)\"\n", + "print \"rotor current per phase is,(A)=\",round(rcp,3)\n", + "print \"power factor is,=\",round(pf,3)\n", + "r3=3.;#ohms\n", + "r4=r1+r3;#rotor resistance ohms per phase\n", + "r2=4.;#rotor reactance ohms per phase\n", + "r=sqrt(r4**2+r2**2);#rotor impedence per phase\n", + "rcp=(vi/r);#rotor current per phase\n", + "pf=(r4/r);#power factor\n", + "print \"part (b)\"\n", + "print \"rotor current per phase is,(A)=\",round(rcp,3)\n", + "print \"power factor is,=\",round(pf,3)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12 : pg 127" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "part (a) generator \n", + "emf when the armature current is full load unit pf is,(V)= 89.444\n", + "emf when the armature current is full load 0.8 pf (lag) is,(V)= 112.857\n", + "emf when the armature current is full load 0.8 pf (lead) is,(V)= 56.71\n", + "part (b) motor\n", + "emf when the armature current is full load unit pf is,(V)= 89.444\n", + "emf when the armature current is full load 0.8 pf (lag) is,(V)= 56.71\n", + "emf when the armature current is full load 0.8 pf (lead) is,(V)= 112.857\n" + ] + } + ], + "source": [ + "#Example 6.12# emf\n", + "#calculate the emf\n", + "from math import sqrt, pi\n", + "#given:\n", + "print \"part (a) generator \"\n", + "kva=4.;#kVA\n", + "v=110.;#volts\n", + "re=3.;#syncronous reacrance in ohms\n", + "#calculations and results\n", + "ip=((kva*10**3)/(sqrt(3)*v));#phase current in Amperes\n", + "ep=v/(sqrt(3));#phase voltage in volts\n", + "e1=ep+1j*(ip*3);#line voltage in volts\n", + "e11=sqrt((e1.real**2)+e1.imag**2);#line voltage per phase in volts\n", + "pf=0.8;#power factor\n", + "e12=(sqrt((e1.real*pf)**2+(((e1.imag*sqrt(1-pf**2))+e1.imag))**2));#\n", + "e13=(sqrt((e1.real*pf)**2+(((e1.imag*sqrt(1-pf**2))-e1.imag))**2));#\n", + "print \"emf when the armature current is full load unit pf is,(V)=\",round(e11,3)\n", + "print \"emf when the armature current is full load 0.8 pf (lag) is,(V)=\",round(e12,3)\n", + "print \"emf when the armature current is full load 0.8 pf (lead) is,(V)=\",round(e13,3)\n", + "print \"part (b) motor\"\n", + "kva=4;#kVa\n", + "v=110;#volts\n", + "re=3;#syncronous reacrance in ohms\n", + "ip=((kva*10**3)/(sqrt(3)*v));#phase current in Amperes\n", + "ep=v/(sqrt(3));#phase voltage in volts\n", + "e1=ep-1j*(ip*3);#line voltage in volts\n", + "e11=sqrt((e1.real**2)+e1.imag**2);#line voltage per phase in volts\n", + "pf=0.8;#power factor\n", + "e12=(sqrt((e1.real*pf)**2+(((e1.imag*sqrt(1-pf**2))-e1.imag))**2));#\n", + "e13=(sqrt((e1.real*pf)**2+(((e1.imag*sqrt(1-pf**2))+e1.imag))**2));#\n", + "print \"emf when the armature current is full load unit pf is,(V)=\",round(e11,3)\n", + "print \"emf when the armature current is full load 0.8 pf (lag) is,(V)=\",round(e12,3)\n", + "print \"emf when the armature current is full load 0.8 pf (lead) is,(V)=\",round(e13,3)\n" + ] + } + ], + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter7.ipynb b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter7.ipynb new file mode 100644 index 00000000..b0a3b759 --- /dev/null +++ b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/Chapter7.ipynb @@ -0,0 +1,177 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 7 : Electrothermal energy conversion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1 : pg 135" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "length is,(m)= 16.201\n", + "width is,(mm)= 12.345\n" + ] + } + ], + "source": [ + "#Example 7.1# width and length\n", + "#calculate the length and width\n", + "from math import sqrt\n", + "#given:\n", + "vph=400.;#phase voltage in volts\n", + "n=3.;#number of phase\n", + "kw=36.;#power in kW\n", + "#calculations\n", + "r=((vph**2)/(n*((kw*10**3)/n)));#resistance in ohms\n", + "p=1.016*10**-6;#resitivity\n", + "t=0.3;#thickness in mm\n", + "x=(((r*t*10**-3)/(p)));#variable\n", + "t1=1000;#initial temperature in degree celsius\n", + "t1k=273+t1;#initial temperature in kelvin\n", + "t2=650;#final temperature in degree celsius\n", + "t2k=273+t2;#final temperature in kelvin\n", + "h=((3*10**4)*((t1k/1000)**4-(t2k/1000)**4));#W/m**2\n", + "y=((kw*10**3)/(3*2*h));#variable\n", + "l=sqrt(x*y);#length in meter\n", + "w=y/l;#width in meter\n", + "#results\n", + "print \"length is,(m)=\",round(l,3)\n", + "print \"width is,(mm)=\",round(w*10**3,3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2 : pg 138" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "power required is,(W)= 100.0\n" + ] + } + ], + "source": [ + "#Example 7.2# \n", + "#calculate the power required\n", + "#given:\n", + "l=0.2;#length in meter\n", + "w=0.1;#width in meter\n", + "th=25.;#thickness in mm\n", + "#calculations\n", + "vw=l*w*th*10**-3;#volume in m**3\n", + "ww=600.;#weight of wood in kg/m**3\n", + "ww1=vw*ww;#weight of wood kg\n", + "shw=1500.;#specific heat of wood in J/kg/degree celsius\n", + "t=200.;#temperature in degree celsius\n", + "rg=t*shw*ww1;#energy in joules\n", + "h=(rg/(3.6*10**3));#Wh\n", + "t=15.;#time in minutes\n", + "pr=h*(60./t);#power required in Watt\n", + "#results\n", + "print \"power required is,(W)=\",pr\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3 : pg 140" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "voltage is ,(V)= 424.0\n", + "current is,(A)= 4.717\n" + ] + } + ], + "source": [ + "#Example 7.3# voltage and current\n", + "#calculate the current and voltage\n", + "from math import sqrt, acos, pi\n", + "l=0.2;#length meter\n", + "w=0.1;#width in meter\n", + "th=25;#thickness in mm\n", + "#calculations\n", + "vw=l*w*th*10**-3;#volume of wood in m**3\n", + "ww=600;#weight of wood in kg/m**3\n", + "ww1=vw*ww;#weight of wood kg\n", + "shw=1500.;#specific heat of wood in J/kg/degree celsius\n", + "t=200.;#temperature in degree celsius\n", + "rg=t*shw*ww1;#energy in joules\n", + "h=(rg/(3.6*10**3));#Wh\n", + "t=15.;#time in minutes\n", + "pr=h*(60./t);#power required in Watt\n", + "eo=8.854*10**-12;#permittivity constant\n", + "er=5.;#permittivity of wood\n", + "c=((eo*er*l*w)/(th*10**-3));#capacitance in Farads\n", + "f=50;#frequency in MHz\n", + "pf=0.5;#power factor \n", + "ph=acos(pf);#phase angle radians\n", + "v=sqrt((pr)/(c*2*pi*f*10**6*0.05));#voltage in volts\n", + "ic=v*2*pi*f*10**6*c;#current in amperes\n", + "#results\n", + "print \"voltage is ,(V)=\",round(v)\n", + "print \"current is,(A)=\",round(ic,3)\n" + ] + } + ], + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter2.png b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter2.png new file mode 100644 index 00000000..660188c9 Binary files /dev/null and b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter2.png differ diff --git a/Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter3.png b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter3.png new file mode 100644 index 00000000..8218d85c Binary files /dev/null and b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter3.png differ diff --git a/Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter4.png b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter4.png new file mode 100644 index 00000000..9c5b9f26 Binary files /dev/null and b/Elements_of_electrical_science_by_Mukopadhyay,_Pant/screenshots/chapter4.png differ diff --git a/sample_notebooks/Harshitgarg/Chapter_1-INTRODUCTION_TO_MECHANICS_OF_SOLIDS__1.ipynb b/sample_notebooks/Harshitgarg/Chapter_1-INTRODUCTION_TO_MECHANICS_OF_SOLIDS__1.ipynb new file mode 100644 index 00000000..0ded7c3f --- /dev/null +++ b/sample_notebooks/Harshitgarg/Chapter_1-INTRODUCTION_TO_MECHANICS_OF_SOLIDS__1.ipynb @@ -0,0 +1,366 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "example1.1 Page number 10\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " The resultant velocity : 21.54 km/hour\n", + "68.2 °\n" + ] + } + ], + "source": [ + "#downstream direction as x\n", + "#direction across river as y\n", + "\n", + "from math import sqrt,atan,pi\n", + "\n", + "#variable declaration\n", + "\n", + "Vx= 8 #velocity of stream, km/hour\n", + "Vy=float(20) #velocity of boat,km/hour\n", + "\n", + "V=sqrt(pow(Vx,2)+pow(Vy,2)) #resultant velocity, km/hour\n", + "theta=Vy/Vx\n", + "\n", + "alpha= atan(theta)*180/pi #angle, degrees \n", + "\n", + "print \" The resultant velocity :\",round(V,2),\"km/hour\"\n", + "print round(alpha,2),\"°\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " example 1.2 Page number 10" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10.0 KN (to the left)\n", + "17.32 KN (downward)\n" + ] + } + ], + "source": [ + "\n", + "\n", + "\n", + "#components of force in horizontal and vertical components. \n", + "from math import cos,sin,pi\n", + "#variable declaration\n", + "\n", + "F= 20 #force in wire, KN\n", + "\n", + "#calculations\n", + "Fx= F*cos(60*pi/180) \n", + "Fy= F*sin(60*pi/180)\n", + "\n", + "print round(Fx,2),\"KN\" ,\"(to the left)\"\n", + "print round(Fy,2), \"KN\" ,\"(downward)\"\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "example 1.3 Page number 11" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Component normal to the plane : 9.4 KN\n", + "Component parallel to the plane : 3.42 KN\n" + ] + } + ], + "source": [ + "\n", + "\n", + " #The plane makes an angle of 20° to the horizontal. Hence the normal to the plane makes an angles of 70° to the horizontal i.e., 20° to the vertical\n", + "from math import cos,sin,pi\n", + "#variable declaration\n", + "W= 10 # black weighing, KN\n", + "\n", + "#calculations\n", + "\n", + "Nor= W*cos(20*pi/180) #Component normal to the plane\n", + "para= W*sin(20*pi/180) #Component parallel to the plane\n", + "\n", + "print \"Component normal to the plane :\",round(Nor,2),\"KN\"\n", + "print \"Component parallel to the plane :\",round(para,2) , \"KN\"\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "example 1.4 Page number 11" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F1= 100.0 N\n", + "F2= 200.0 N\n", + "theta= 63.9 °\n" + ] + } + ], + "source": [ + "\n", + "\n", + "#Let the magnitude of the smaller force be F. Hence the magnitude of the larger force is 2F\n", + "\n", + "from math import pi,sqrt, acos\n", + "#variable declaration\n", + "R1=260 #resultant of two forces,N\n", + "R2=float(180) #resultant of two forces if larger force is reversed,N\n", + "\n", + "\n", + "\n", + "#calculations\n", + "\n", + "F=sqrt((pow(R1,2)+pow(R2,2))/10)\n", + "F1=F\n", + "F2=2*F\n", + "theta=acos((pow(R1,2)-pow(F1,2)-pow(F2,2))/(2*F1*F2))*180/pi\n", + "\n", + "print \"F1=\",F1,\"N\"\n", + "print \"F2=\",F2,\"N\"\n", + "print \"theta=\",round(theta,1),\"°\"\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "example 1.5 Page number 12" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F1= 326.35 N\n", + "F2= 223.24 N\n" + ] + } + ], + "source": [ + "\n", + "\n", + "#Let ?ABC be the triangle of forces drawn to some scale\n", + "#Two forces F1 and F2 are acting at point A\n", + "#angle in degrees '°'\n", + "\n", + "from math import sin,pi\n", + " \n", + "#variabble declaration\n", + "cnv=pi/180\n", + "\n", + "BAC = 20*cnv #Resultant R makes angle with F1 \n", + " \n", + "ABC = 130*cnv \n", + "\n", + "ACB = 30*cnv \n", + "\n", + "R = 500 #resultant force,N\n", + "\n", + "#calculations\n", + "#sinerule\n", + "\n", + "F1=R*sin(ACB)/sin(ABC)\n", + "F2=R*sin(BAC)/sin(ABC)\n", + "\n", + "print \"F1=\",round(F1,2),\"N\"\n", + "print \"F2=\",round(F2,2),\"N\"\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "example 1.6 Page number 12" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta= 78.13 °\n", + "alpha= 29.29 °\n" + ] + } + ], + "source": [ + "\n", + "\n", + "#Let ABC be the triangle of forces,'theta' be the angle between F1 and F2, and 'alpha' be the angle between resultant and F1 \n", + "\n", + "from math import sin,acos,asin,pi\n", + "\n", + "#variable declaration\n", + "cnv= 180/pi\n", + "F1=float(400) #all forces are in newtons,'N'\n", + "F2=float(260)\n", + "R=float(520)\n", + "\n", + "#calculations\n", + "\n", + "theta=acos((pow(R,2)-pow(F1,2)-pow(F2,2))/(2*F1*F2))*cnv\n", + "\n", + "alpha=asin(F2*sin(theta*pi/180)/R)*cnv\n", + "\n", + "print\"theta=\",round(theta,2),\"°\"\n", + "print \"alpha=\",round(alpha,2),\"°\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "example 1.7 Page number 13" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "horizontal component= 2814.2 N\n", + "Vertical component = 1039.2 N\n", + "Component along crank = 507.1 N\n", + "Component normal to crank= 2956.8 N\n" + ] + } + ], + "source": [ + "\n", + "\n", + "#The force of 3000 N acts along line AB. Let AB make angle alpha with horizontal.\n", + "\n", + "from math import cos,sin,pi,asin,acos\n", + "\n", + "#variable declaration\n", + "F=3000 #force in newtons,'N'\n", + "BC=80 #length of crank BC, 'mm'\n", + "AB=200 #length of connecting rod AB ,'mm'\n", + "theta=60*pi/180 #angle b/w BC & AC\n", + "\n", + "#calculations\n", + "\n", + "alpha=asin(BC*sin(theta)/200)*180/pi\n", + "\n", + "HC=F*cos(alpha*pi/180) #Horizontal component \n", + "VC= F*sin(alpha*pi/180) #Vertical component \n", + "\n", + "#Components along and normal to crank\n", + "#The force makes angle alpha + 60 with crank.\n", + "alpha2=alpha+60\n", + "CAC=F*cos(alpha2*pi/180) # Component along crank \n", + "CNC= F*sin(alpha2*pi/180) #Component normal to crank \n", + "\n", + "\n", + "print \"horizontal component=\",round(HC,1),\"N\"\n", + "print \"Vertical component = \",round(VC,1),\"N\"\n", + "print \"Component along crank =\",round(CAC,1),\"N\"\n", + "print \"Component normal to crank=\",round(CNC,1),\"N\"" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [Root]", + "language": "python", + "name": "Python [Root]" + }, + "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": 0 +} -- cgit