From f270f72badd9c61d48f290c3396004802841b9df Mon Sep 17 00:00:00 2001 From: kinitrupti Date: Fri, 12 May 2017 18:53:46 +0530 Subject: Removed duplicates --- .../CH_1.ipynb | 731 +++++++++++++++++ .../CH_10.ipynb | 222 ++++++ .../CH_11.ipynb | 354 +++++++++ .../CH_2.ipynb | 623 +++++++++++++++ .../CH_3.ipynb | 883 +++++++++++++++++++++ .../CH_4.ipynb | 499 ++++++++++++ .../CH_5.ipynb | 435 ++++++++++ .../CH_6.ipynb | 311 ++++++++ .../CH_7.ipynb | 400 ++++++++++ .../CH_8.ipynb | 337 ++++++++ .../CH_9.ipynb | 625 +++++++++++++++ .../README.txt | 10 + .../screenshots/1.png | Bin 0 -> 35222 bytes .../screenshots/2.png | Bin 0 -> 34615 bytes .../screenshots/3.png | Bin 0 -> 34828 bytes 15 files changed, 5430 insertions(+) create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_1.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_10.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_11.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_2.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_3.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_4.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_5.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_6.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_7.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_8.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_9.ipynb create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/README.txt create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/1.png create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/2.png create mode 100755 Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/3.png (limited to 'Fundamentals_of_Electrical_Machines_by_M_A_Salam') diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_1.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_1.ipynb new file mode 100755 index 00000000..801b1ed1 --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_1.ipynb @@ -0,0 +1,731 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 1: REVIEW OF ELECTRIC CIRCUITS" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.1, Page number 2-3" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Q = 4.0 #Charge(C) \n", + "t = 0.54 #Time(sec) \n", + "\n", + "#Calculation\n", + "I = Q/t #Current(A) \n", + "\n", + "#Result\n", + "print('Value of Current is , I = %.2f A' %I) " + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of Current is , I = 7.41 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.2, Page number 4-5" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V = -24.0 #Voltage(V)\n", + "I = 3.0 #Current(A)\n", + "\n", + "#Calculation \n", + "P = V*I #Power supplied by the element A(W) \n", + "\n", + "#Result\n", + "print('Power supplied by the element A is , P = %.1f W' %P)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Power supplied by the element A is , P = -72.0 W\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.3, Page number 7-9" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "R1 = 5.0 #Resistance(ohm)\n", + "R2 = 4.0 #Resistance(ohm)\n", + "R3 = 9.0 #Resistance(ohm)\n", + "R4 = 6.0 #Resistance(ohm)\n", + "V1 = 10.0 #Resistance(ohm)\n", + "V2 = 6.0 #Resistance(ohm)\n", + "\n", + "\n", + "#Calculation\n", + "R_th = (R1*R4/(R1+R4))+R2 #Thevenin resistance(ohm) by removing R3 & short-circuiting voltage sources\n", + "I = (V1-V2)/(R1+R4) #Current(A) by applying KVL\n", + "V_th = 6*I+V2 #Thevenin voltage(V) by applying KVL\n", + "I_9ohm = V_th/(R_th+R3) #Current through 9 ohm resistor(A)\n", + "\n", + "#Result\n", + "print('Current through 9 ohm resistor , I_9\u03a9 = %.2f A' %I_9ohm) " + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Current through 9 ohm resistor , I_9\u03a9 = 0.52 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.4, Page number 10-11" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from scipy.integrate import quad\n", + "\n", + "#Variable declaration\n", + "V_t1 = 30.0 #Magnitudes of voltages(V) 0 < t1 < 2\n", + "V_t2 = -10.0 #Magnitudes of voltages(V) 2 < t2 < 4\n", + "T = 4.0 #Time period(sec) from figure\n", + "\n", + "#Calculation\n", + "def integrand(V):\n", + " return V**0\n", + "\n", + "a, err = quad(integrand, 0, 2)\n", + "\n", + "def integrand(V):\n", + " return V**0\n", + "\n", + "b, err = quad(integrand, 2, 4)\n", + "\n", + "V_rms = ((a*V_t1**2+b*V_t2**2)/4)**0.5 #RMS value of voltage waveform(V)\n", + "\n", + "#Result\n", + "print('RMS value , V_rms = %.2f V' %V_rms)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "RMS value , V_rms = 22.36 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.5, Page number 15-16" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "V_P = 200.0 #Magnitude of each phase(V) \n", + "\n", + "#Calculation\n", + "V_an = V_P*cmath.exp(1j*0*math.pi/180) #Magnitude of 3-phase voltage(V)\n", + "V_bn = V_P*cmath.exp(1j*-120*math.pi/180) #Magnitude of 3-phase voltage(V)\n", + "V_cn = V_P*cmath.exp(1j*120*math.pi/180) #Magnitude of 3-phase voltage(V)\n", + "V_L = 3**0.5*V_P #Magnitude of line voltage(V)\n", + "\n", + "#Result\n", + "print('Expression of phase voltages are,')\n", + "print('\\t\\t\\t V_an = %.f\u2220%.f\u00b0 V' %(abs(V_an),cmath.phase(V_an)))\n", + "print('\\t\\t\\t V_bn = %.f\u2220%.f\u00b0 V' %(abs(V_bn),cmath.phase(V_bn)*180/math.pi))\n", + "print('\\t\\t\\t V_cn = %.f\u2220%.f\u00b0 V' %(abs(V_cn),cmath.phase(V_cn)*180/math.pi))\n", + "print('Magnitude of the line voltage , V_L = %.1f V' %V_L) " + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Expression of phase voltages are,\n", + "\t\t\t V_an = 200\u22200\u00b0 V\n", + "\t\t\t V_bn = 200\u2220-120\u00b0 V\n", + "\t\t\t V_cn = 200\u2220120\u00b0 V\n", + "Magnitude of the line voltage , V_L = 346.4 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.6, Page number 16-17" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "R = 10.0 #Resistance of each coil(ohm)\n", + "X = 15.0 #Inductive reactance of each coil(ohm)\n", + "V_L = 420.0 #Line voltage(V)\n", + "f = 50.0 #Frequency of supply(Hz)\n", + "\n", + "#Calculation\n", + "V_an = (V_L/3**0.5)*cmath.exp(1j*(0-30)*math.pi/180) #Phase voltage(V)\n", + "V_bn = (V_L/3**0.5)*cmath.exp(1j*(-120-30)*math.pi/180) #Phase voltage(V)\n", + "V_cn = (V_L/3**0.5)*cmath.exp(1j*(120-30)*math.pi/180) #Phase voltage(V)\n", + "Z_P = complex(R,X) #Phase impedance(ohm)\n", + "#For case(i)\n", + "I_L1 = V_an/Z_P #Line current(A)\n", + "I_L2 = V_bn/Z_P #Line current(A)\n", + "I_L3 = V_cn/Z_P #Line current(A)\n", + "#For case(ii)\n", + "pf = R/abs(Z_P) #Power factor\n", + "\n", + "#Result\n", + "print('(i) Values of line currents are,')\n", + "print('\\t I_L1 = I_an = %.2f\u2220%.2f\u00b0 A' %(abs(I_L1),cmath.phase(I_L1)*180/math.pi))\n", + "print('\\t I_L2 = I_bn = %.2f\u2220%.2f\u00b0 A' %(abs(I_L2),cmath.phase(I_L2)*180/math.pi))\n", + "print('\\t I_L3 = I_cn = %.2f\u2220%.2f\u00b0 A' %(abs(I_L3),cmath.phase(I_L3)*180/math.pi))\n", + "print('(ii) Power factor is , pf = %.1f lag' %pf)\n", + "print('\\nNOTE : I_L2 has an angle -206.31\u00b0 in textbook which is same as 153.69\u00b0 i.e (360-206.31)\u00b0 obtained here')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Values of line currents are,\n", + "\t I_L1 = I_an = 13.45\u2220-86.31\u00b0 A\n", + "\t I_L2 = I_bn = 13.45\u2220153.69\u00b0 A\n", + "\t I_L3 = I_cn = 13.45\u222033.69\u00b0 A\n", + "(ii) Power factor is , pf = 0.6 lag\n", + "\n", + "NOTE : I_L2 has an angle -206.31\u00b0 in textbook which is same as 153.69\u00b0 i.e (360-206.31)\u00b0 obtained here\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.7, Page number 19-20" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "Z_P = complex(10,15) #Per phase impedance(ohm)\n", + "V_L = 420.0 #Voltage(V)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "V_ab = V_L*cmath.exp(1j*0*math.pi/180) #Phase voltage(V)\n", + "V_bc = V_L*cmath.exp(1j*-120*math.pi/180) #Phase voltage(V)\n", + "V_ca = V_L*cmath.exp(1j*120*math.pi/180) #Phase voltage(V)\n", + "I_ab = V_ab/Z_P #Phase current(A)\n", + "I_bc = V_bc/Z_P #Phase current(A)\n", + "I_ca = V_ca/Z_P #Phase current(A)\n", + "#For case(ii)\n", + "I_P = abs(I_ab) #Phase current magnitude(A)\n", + "I_L = 3**0.5*I_P #Line current magnitude(A)\n", + "\n", + "#Result\n", + "print('(i) Phase currents are,')\n", + "print('\\t\\t I_ab = %.2f\u2220%.2f\u00b0 A' %(abs(I_ab),cmath.phase(I_ab)*180/math.pi))\n", + "print('\\t\\t I_bc = %.2f\u2220%.2f\u00b0 A' %(abs(I_bc),cmath.phase(I_bc)*180/math.pi))\n", + "print('\\t\\t I_ca = %.2f\u2220%.2f\u00b0 A' %(abs(I_ca),cmath.phase(I_ca)*180/math.pi))\n", + "print('(ii) Magnitude of line current , I_L = %.2f A' %I_L)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Phase currents are,\n", + "\t\t I_ab = 23.30\u2220-56.31\u00b0 A\n", + "\t\t I_bc = 23.30\u2220-176.31\u00b0 A\n", + "\t\t I_ca = 23.30\u222063.69\u00b0 A\n", + "(ii) Magnitude of line current , I_L = 40.35 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.8, Page number 22-23" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "V_P = 280.0 #Generator Phase voltage(V)\n", + "Z_P = complex(2,3) #Line impedance per phase(ohm)\n", + "Z_L = complex(4,5) #Load impedance per phase(ohm)\n", + "\n", + "#Calculation\n", + "V_An = V_P*cmath.exp(1j*0*math.pi/180) #Phase voltage(V)\n", + "V_Bn = V_P*cmath.exp(1j*-120*math.pi/180) #Phase voltage(V)\n", + "V_Cn = V_P*cmath.exp(1j*120*math.pi/180) #Phase voltage(V)\n", + "Z_t = Z_P+Z_L #Total impedance(ohm)\n", + "I_Aa = V_An/Z_t #Magnitude of line current for phase A(A)\n", + "I_Bb = V_Bn/Z_t #Magnitude of line current for phase B(A)\n", + "I_Cc = V_Cn/Z_t #Magnitude of line current for phase C(A)\n", + "V_an = I_Aa*Z_L #Phase voltage of load(V)\n", + "V_bn = I_Bb*Z_L #Phase voltage of load(V)\n", + "V_cn = I_Cc*Z_L #Phase voltage of load(V)\n", + "\n", + "#Result\n", + "print('Line currents are,')\n", + "print('\\t\\t I_Aa = %.f\u2220%.f\u00b0 A' %(abs(I_Aa),cmath.phase(I_Aa)*180/math.pi))\n", + "print('\\t\\t I_Bb = %.f\u2220%.f\u00b0 A' %(abs(I_Bb),cmath.phase(I_Bb)*180/math.pi))\n", + "print('\\t\\t I_Cc = %.f\u2220%.f\u00b0 A' %(abs(I_Cc),cmath.phase(I_Cc)*180/math.pi))\n", + "print('\\nLoad phase voltages are,')\n", + "print('\\t\\t V_an = %.1f\u2220%.1f\u00b0 V' %(abs(V_an),cmath.phase(V_an)*180/math.pi))\n", + "print('\\t\\t V_bn = %.1f\u2220%.1f\u00b0 V' %(abs(V_bn),cmath.phase(V_bn)*180/math.pi))\n", + "print('\\t\\t V_cn = %.1f\u2220%.1f\u00b0 V' %(abs(V_cn),cmath.phase(V_cn)*180/math.pi))\n", + "print('\\nNOTE : ERROR : Z_L = 6.4\u222038.6\u00b0\u03a9 is taken in textbook solution instead of 6.4\u222051.34\u00b0\u03a9 = (4+j5)\u03a9')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line currents are,\n", + "\t\t I_Aa = 28\u2220-53\u00b0 A\n", + "\t\t I_Bb = 28\u2220-173\u00b0 A\n", + "\t\t I_Cc = 28\u222067\u00b0 A\n", + "\n", + "Load phase voltages are,\n", + "\t\t V_an = 179.3\u2220-1.8\u00b0 V\n", + "\t\t V_bn = 179.3\u2220-121.8\u00b0 V\n", + "\t\t V_cn = 179.3\u2220118.2\u00b0 V\n", + "\n", + "NOTE : ERROR : Z_L = 6.4\u222038.6\u00b0\u03a9 is taken in textbook solution instead of 6.4\u222051.34\u00b0\u03a9 = (4+j5)\u03a9\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.9, Page number 23-24" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "Z = complex(6,8) #Per phase impedance of load(ohm)\n", + "V_AN = 340.0*cmath.exp(1j*0*math.pi/180) #Phase voltage(V)\n", + "\n", + "#Calculation\n", + "V_P = abs(V_AN) #Voltage(V)\n", + "V_BN = V_P*cmath.exp(1j*-120*math.pi/180) #Phase voltage(V)\n", + "V_CN = V_P*cmath.exp(1j*120*math.pi/180) #Phase voltage(V)\n", + "I_an = V_AN/Z #Load current(A)\n", + "I_bn = V_BN/Z #Load current(A)\n", + "I_cn = V_CN/Z #Load current(A)\n", + "I_n = I_an+I_bn+I_cn #Neutral current(A)\n", + "\n", + "#Result\n", + "print('Phase current in each load = Line current in each load are,')\n", + "print('\\t\\t\\t\\t I_an = I_Aa = %.f\u2220%.f\u00b0 A' %(abs(I_an),cmath.phase(I_an)*180/math.pi))\n", + "print('\\t\\t\\t\\t I_bn = I_Bb = %.f\u2220%.f\u00b0 A' %(abs(I_bn),cmath.phase(I_bn)*180/math.pi))\n", + "print('\\t\\t\\t\\t I_cn = I_Cc = %.f\u2220%.f\u00b0 A' %(abs(I_cn),cmath.phase(I_cn)*180/math.pi))\n", + "print('Neutral current is , I_n = %.f A' %abs(I_n))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Phase current in each load = Line current in each load are,\n", + "\t\t\t\t I_an = I_Aa = 34\u2220-53\u00b0 A\n", + "\t\t\t\t I_bn = I_Bb = 34\u2220-173\u00b0 A\n", + "\t\t\t\t I_cn = I_Cc = 34\u222067\u00b0 A\n", + "Neutral current is , I_n = 0 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.10, Page number 25-26" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "Z = complex(3,4) #Per phase impedance of load(ohm)\n", + "V_AN = 200.0*cmath.exp(1j*0*math.pi/180) #Phase voltage(V)\n", + "\n", + "#Calculation\n", + "V_P = abs(V_AN) #Voltage(V)\n", + "V_AB = 3**0.5*V_P*cmath.exp(1j*30*math.pi/180) #Line voltage(V)\n", + "V_BC = 3**0.5*V_P*cmath.exp(1j*-90*math.pi/180) #Line voltage(V)\n", + "V_CA = 3**0.5*V_P*cmath.exp(1j*150*math.pi/180) #Line voltage(V)\n", + "#For case(i)\n", + "I_ab = V_AB/Z #Load current(A)\n", + "I_bc = V_BC/Z #Load current(A)\n", + "I_ca = V_CA/Z #Load current(A)\n", + "#For case(ii)\n", + "I_Aa = I_ab-I_ca #Line current(A)\n", + "I_Bb = I_bc-I_ab #Line current(A)\n", + "I_Cc = I_ca-I_bc #Line current(A)\n", + "\n", + "#Result\n", + "print('(i) Magnitude of load currents are,')\n", + "print('\\t\\t I_ab = %.1f\u2220%.2f\u00b0 A' %(abs(I_ab),cmath.phase(I_ab)*180/math.pi))\n", + "print('\\t\\t I_bc = %.1f\u2220%.2f\u00b0 A' %(abs(I_bc),cmath.phase(I_bc)*180/math.pi))\n", + "print('\\t\\t I_ca = %.1f\u2220%.2f\u00b0 A' %(abs(I_ca),cmath.phase(I_ca)*180/math.pi))\n", + "print('\\n(ii) Magnitude of line currents are,')\n", + "print('\\t\\t I_Aa = %.2f\u2220%.2f\u00b0 A' %(abs(I_Aa),cmath.phase(I_Aa)*180/math.pi))\n", + "print('\\t\\t I_Bb = %.2f\u2220%.2f\u00b0 A' %(abs(I_Bb),cmath.phase(I_Bb)*180/math.pi))\n", + "print('\\t\\t I_Cc = %.2f\u2220%.2f\u00b0 A' %(abs(I_Cc),cmath.phase(I_Cc)*180/math.pi))\n", + "print('\\nNOTE : ERROR : Calculation mistakes in textbook')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Magnitude of load currents are,\n", + "\t\t I_ab = 69.3\u2220-23.13\u00b0 A\n", + "\t\t I_bc = 69.3\u2220-143.13\u00b0 A\n", + "\t\t I_ca = 69.3\u222096.87\u00b0 A\n", + "\n", + "(ii) Magnitude of line currents are,\n", + "\t\t I_Aa = 120.00\u2220-53.13\u00b0 A\n", + "\t\t I_Bb = 120.00\u2220-173.13\u00b0 A\n", + "\t\t I_Cc = 120.00\u222066.87\u00b0 A\n", + "\n", + "NOTE : ERROR : Calculation mistakes in textbook\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.11, Page number 28-29" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "Z = complex(3,4) #Per phase impedance of load(ohm)\n", + "V_AN = 150.0*cmath.exp(1j*0*math.pi/180) #Phase voltage(V)\n", + "\n", + "#Calculation\n", + "V_P = abs(V_AN) #Voltage(V)\n", + "V_BN = V_P*cmath.exp(1j*-120*math.pi/180) #Phase voltage(V)\n", + "V_CN = V_P*cmath.exp(1j*120*math.pi/180) #Phase voltage(V)\n", + "I_Aa = V_AN/Z #Line current(A)\n", + "I_Bb = V_BN/Z #Line current(A)\n", + "I_Cc = V_CN/Z #Line current(A)\n", + "pf = Z.real/abs(Z) #Power factor\n", + "I = abs(I_Aa) #Magnitude of line current(A)\n", + "P = V_P*I*pf*10**-3 #Power supplied to each phase(kW)\n", + "P_t = 3*P #Total power supplied(kW)\n", + "\n", + "#Result\n", + "print('Line currents are,')\n", + "print(' I_Aa = %.f\u2220%.2f\u00b0 A' %(abs(I_Aa),cmath.phase(I_Aa)*180/math.pi))\n", + "print(' I_Bb = %.f\u2220%.2f\u00b0 A' %(abs(I_Bb),cmath.phase(I_Bb)*180/math.pi))\n", + "print(' I_Cc = %.f\u2220%.2f\u00b0 A' %(abs(I_Cc),cmath.phase(I_Cc)*180/math.pi))\n", + "print('Power factor , pf = %.1f ' %pf)\n", + "print('Power supplied to each phase , P = %.1f kW' %P)\n", + "print('Total Power supplied to the load , P_t = %.1f kW' %P_t)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line currents are,\n", + " I_Aa = 30\u2220-53.13\u00b0 A\n", + " I_Bb = 30\u2220-173.13\u00b0 A\n", + " I_Cc = 30\u222066.87\u00b0 A\n", + "Power factor , pf = 0.6 \n", + "Power supplied to each phase , P = 2.7 kW\n", + "Total Power supplied to the load , P_t = 8.1 kW\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.12, Page number 32" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P = 120.0 #Total power(kW)\n", + "pf = 0.6 #Power factor \n", + "\n", + "#Calculation\n", + "teta = math.acos(pf) #Power factor angle(radians)\n", + "teta_deg = teta*180/math.pi #Power factor angle(degree)\n", + "P_2 = 1.0/2*((math.tan(teta)*P/3**0.5)+P) #Second wattmeter reading(kW)\n", + "\n", + "#Result\n", + "print('Second wattmeter reading , P_2 = %.1f kW' %P_2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Second wattmeter reading , P_2 = 106.2 kW\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.13, Page number 35" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P = 5000.0 #Power(W)\n", + "pf_1 = 0.8 #Initial Power factor\n", + "V = 110.0 #rms Voltage(V)\n", + "f = 50.0 #Frequency(Hz)\n", + "pf_2 = 0.9 #Final Power factor\n", + "\n", + "#Calculation\n", + "phi_1 = math.acos(pf_1) #Initial Power factor angle(radians)\n", + "phi_1_deg = phi_1*180/math.pi #Initial Power factor angle(degree)\n", + "phi_2 = math.acos(pf_2) #Final Power factor angle(radians)\n", + "phi_2_deg = phi_2*180/math.pi #Final Power factor angle(degree)\n", + "C = P*(math.tan(phi_1)-math.tan(phi_2))/(2*math.pi*f*V**2)*10**6 #Parallel capacitance(\u00b5F)\n", + "\n", + "#Result\n", + "print('Capacitance , C = %.1f \u00b5F' %C)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance , C = 349.5 \u00b5F\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.14, Page number 35-36" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "pf_1 = 0.85 #Initial Power factor\n", + "kVA = 20.0 #Load(kVA)\n", + "f = 50.0 #Frequency(Hz)\n", + "pf_2 = 0.95 #Final Power factor\n", + "V = 200.0 #Voltage(V)\n", + "R = 0.05 #Resistance(ohm)\n", + "X = 0.2 #Inductive reactance(ohm)\n", + "\n", + "#Calculation\n", + "phi_1 = math.acos(pf_1) #Initial Power factor angle(radians)\n", + "phi_1_deg = phi_1*180/math.pi #Initial Power factor angle(degree)\n", + "phi_2 = math.acos(pf_2) #Final Power factor angle(radians)\n", + "phi_2_deg = phi_2*180/math.pi #Final Power factor angle(degree)\n", + "P = kVA*pf_1 #Load power(kW)\n", + "C = P*1000*(math.tan(phi_1)-math.tan(phi_2))/(2*math.pi*f*V**2)*10**6 #Parallel capacitance(\u00b5F)\n", + "#Before adding capacitor\n", + "I_1 = P*1000/(pf_1*V) #Line current(A)\n", + "P_1 = I_1**2*R #Power loss in line(W)\n", + "#After adding capacitor\\n\",\n", + "S = P*1000/pf_2 #Apparent power(VA)\n", + "I_2 = S/V #Line current(A)\n", + "P_2 = I_2**2*R #Power loss in line(W)\n", + "\n", + "#Result\n", + "print('Capacitance , C = %.1f \u00b5F' %C)\n", + "print('Power loss in the line before adding capacitor , P_1 = %.1f W' %P_1)\n", + "print('Power loss in the line after adding capacitor , P_2 = %.1f W' %P_2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance , C = 393.8 \u00b5F\n", + "Power loss in the line before adding capacitor , P_1 = 500.0 W\n", + "Power loss in the line after adding capacitor , P_2 = 400.3 W\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_10.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_10.ipynb new file mode 100755 index 00000000..b3532e76 --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_10.ipynb @@ -0,0 +1,222 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 10: SYNCHRONOUS MOTOR" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.1, Page number 335" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "V = 2.5*10**3 #Supply voltage(V)\n", + "R_r = 0.12 #Per phase resistance(ohm)\n", + "X_r = 3.2 #Syncronous reactance(ohm)\n", + "I_a = 185.0 #Line current(A)\n", + "pf = 0.8 #Leading power factor\n", + "\n", + "#Calculation\n", + "phi = math.acos(pf) #Angle(radians)\n", + "phi_deg = phi*180/math.pi #Angle(degree)\n", + "V_t = V/3**0.5 #Terminal voltage per phase(V)\n", + "Z_s = complex(R_r,X_r) #Impedance per phase(ohm)\n", + "beta = math.atan(X_r/R_r) #Angle(radians)\n", + "beta_deg = beta*180/math.pi #Angle(degree)\n", + "E_r = I_a*abs(Z_s) #Resultant voltage due to impedance(V)\n", + "E_f = (V_t**2+E_r**2-2*V_t*E_r*math.cos(beta+phi))**0.5 #Excitation voltage per phase(V)\n", + "\n", + "#Result\n", + "print('Excitation voltage per phase , E = %.2f V' %E_f)\n", + "print('\\nNOTE : Changes in answer is due to precision i.e more number of decimal places')\n", + "print(' ERROR : Line current I_a = 185 A not 180 A as given in textbook question')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Excitation voltage per phase , E = 1846.18 V\n", + "\n", + "NOTE : Changes in answer is due to precision i.e more number of decimal places\n", + " ERROR : Line current I_a = 185 A not 180 A as given in textbook question\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.2, Page number 335-337" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "kVA = 1200.0 #kVA ratings\n", + "V = 14.0*10**3 #Supply voltage(V)\n", + "R_r = 4.8 #Per phase resistance(ohm)\n", + "X_r = 35.0 #Syncronous reactance(ohm)\n", + "pf = 0.95 #Leading power factor\n", + "\n", + "#Calculation\n", + "phi = math.acos(pf) #Angle(radians)\n", + "phi_deg = phi*180/math.pi #Angle(degree)\n", + "Z_s = complex(R_r,X_r) #Impedance per phase(ohm)\n", + "I_a = kVA*10**3/(3**0.5*V) #Armature current(A)\n", + "E_r = I_a*abs(Z_s) #Resultant voltage due to impedance(V)\n", + "V_t = V/3**0.5 #Terminal voltage per phase(V)\n", + "b = math.atan(X_r/R_r) #Beta value(radians)\n", + "b_deg = b*180/math.pi #Beta value(degree)\n", + "E_f = (V_t**2+E_r**2-2*V_t*E_r*math.cos(b-phi))**0.5 #Excitation voltage per phase(V)\n", + "sin_delta = (E_r/E_f)*math.sin(b-phi)\n", + "delta = math.asin(sin_delta)*180/math.pi #Torque angle(degree)\n", + "\n", + "#Result\n", + "print('Excitation voltage per phase , E_f = %.2f V' %E_f)\n", + "print('Torque angle , \u03b4 = %.2f\u00b0' %delta)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Excitation voltage per phase , E_f = 7483.23 V\n", + "Torque angle , \u03b4 = 12.12\u00b0\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.3, Page number 343-344" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "V = 440.0 #Supply voltage(V)\n", + "R_a = 1.5 #Per phase armature resistance(ohm)\n", + "X_a = 8.0 #Synchronous reactance(ohm)\n", + "P = 4.0 #Number of poles\n", + "f = 50.0 #Supply frequency(Hz)\n", + "pf = 0.9 #Leading power factor\n", + "I_a = 50.0 #Armature current(A)\n", + "\n", + "#Calculation\n", + "V_t = V/3**0.5 #Terminal voltage per phase(V)\n", + "phi = math.acos(pf) #Angle(radians)\n", + "phi_deg = phi*180/math.pi #Angle(degree)\n", + "Z_s = complex(R_a,X_a) #Impedance per phase(ohm)\n", + "E_r = I_a*abs(Z_s) #Resultant voltage due to impedance(V)\n", + "beta = math.atan(X_a/R_a) #Beta value(radians)\n", + "beta_deg = beta*180/math.pi #Beta value(degree)\n", + "E_f = (V_t**2+E_r**2-2*V_t*E_r*math.cos(beta+phi))**0.5 #Excitation voltage per phase(V)\n", + "P_dm = (((E_f*V_t)/abs(Z_s))-((E_f**2*R_a)/abs(Z_s)**2)) #Maximum power per phase(W)\n", + "\n", + "#Result \n", + "print('Maximum power per phase , P_dm = %.1f W' %P_dm)\n", + "print('\\nNOTE : ERROR : In textbook solution E_f = 513.5 V is taken instead of 533.337089826 V')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum power per phase , P_dm = 10205.3 W\n", + "\n", + "NOTE : ERROR : In textbook solution E_f = 513.5 V is taken instead of 533.337089826 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.4, Page number 344" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P = 4.0 #Number of poles\n", + "f = 50.0 #Supply frequency(Hz)\n", + "V_t = 1500.0 #Terminal voltage per phase(V)\n", + "E_f = 1000.0 #Excitation voltage per phase(V)\n", + "Z_s = 12.0 #Synchronous impedance per phase(ohm)\n", + "R_a = 1.5 #Armature resistance(ohm)\n", + "\n", + "#Caclulation\n", + "P_dm = ((E_f*V_t/Z_s)-(E_f**2*R_a/Z_s**2)) #Maximum power(W)\n", + "N_s = 120*f/P #Synchronous speed(rpm)\n", + "T_dm = 9.55*P_dm/N_s #Maximum torque(N-m)\n", + "\n", + "#Result \n", + "print('Maximum power developed , P_dm = %.f W' %P_dm)\n", + "print('Maximum toruqe , T_dm = %.1f N-m' %T_dm)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum power developed , P_dm = 114583 W\n", + "Maximum toruqe , T_dm = 729.5 N-m\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_11.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_11.ipynb new file mode 100755 index 00000000..3c86183e --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_11.ipynb @@ -0,0 +1,354 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 11: SINGLE-PHASE MOTORS" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.1, Page number 354-355" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V = 220.0 #Supply voltage(V)\n", + "P = 4.0 #Number of poles\n", + "f = 50.0 #Frequency(Hz)\n", + "N_l = 1450.0 #Speed(rpm)\n", + "R_2 = 10.0 #Rotor resistance at standstill(ohm)\n", + "\n", + "#Calculation\n", + "N_s = 120*f/P #Synchronous speed(rpm)\n", + "#For case(i)\n", + "s_f = (N_s-N_l)/N_s #Slip due to forward field\n", + "#For case(ii)\n", + "s_b = 2-s_f #Slip due to backward field\n", + "#For case(iii)\n", + "R_f = R_2/s_f #Effective rotor resistance due to forward slip(ohm)\n", + "R_b = R_2/(2-s_f) #Effective rotor resistance due to backward slip(ohm)\n", + "\n", + "#Result\n", + "print('(i) Slip due to forward field , s_f = %.2f ' %s_f)\n", + "print('(ii) Slip due to backward field , s_b = %.2f ' %s_b)\n", + "print('(iii) Effective rotor resistance due to forward slip , R_f = %.2f ohm' %R_f)\n", + "print(' Effective rotor resistance due to backward slip , R_b = %.2f ohm' %R_b)\n", + "print('\\nNOTE : Changes in answer from that of textbook is due to precision')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Slip due to forward field , s_f = 0.03 \n", + "(ii) Slip due to backward field , s_b = 1.97 \n", + "(iii) Effective rotor resistance due to forward slip , R_f = 300.00 ohm\n", + " Effective rotor resistance due to backward slip , R_b = 5.08 ohm\n", + "\n", + "NOTE : Changes in answer from that of textbook is due to precision\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.2, Page number 357-358" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "V_t = 220.0 #Supply voltage(V)\n", + "R_1 = 6.0 #Resistance(ohm)\n", + "R_2 = 6.0 #Resistance(ohm)\n", + "X_1 = 10.0 #Inductive reactance(ohm)\n", + "X_2 = 10.0 #Inductive reactance(ohm)\n", + "N = 1500.0 #Speed(rpm)\n", + "s = 0.03 #Slip\n", + "X_m = 150.0 #Inductive reactance(ohm)\n", + "\n", + "#Calculation\n", + "Z_f = 0.5*complex(0,X_m)*complex(R_2/s,X_2)/complex(R_2/s,X_2+X_m) #Impedance due to forward field(ohm)\n", + "Z_b = 0.5*complex(0,X_m)*complex(R_2/(2-s),X_2)/complex(R_2/(2-s),X_2+X_m) #Impedance due to backward field(ohm)\n", + "Z_t = complex(R_1+Z_f+Z_b,X_1) #Total impedance(ohm)\n", + "#For case(i)\n", + "I_1 = V_t/Z_t #Input current(A)\n", + "#For case(ii)\n", + "P_i = V_t*abs(I_1) #Input power(W)\n", + "#For case(iii)\n", + "R_f = Z_f.real\n", + "R_b = Z_b.real\n", + "P_d = abs(I_1)**2*(R_f-R_b)*(1-s) #Power developed(W)\n", + "#For case(iv)\n", + "T_d = 9.55*P_d/N #Torque(N-m)\n", + "\n", + "#Result\n", + "print('(i) Input current , I_1 = %.2f\u2220%.1f\u00b0 A' %(abs(I_1),cmath.phase(I_1)*180/math.pi))\n", + "print('(ii) Input power , P_i = %.2f W' %P_i)\n", + "print('(iii) Power developed , P_d = %.1f W' %P_d)\n", + "print('(iv) Torque developed , T_d = %.2f N-m' %T_d)\n", + "print('\\nNOTE : Case(ii) is not solved in textbook but solved here')\n", + "print(' ERROR : Calculation mistake in Z_b in textbook solution')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Input current , I_1 = 2.94\u2220-56.2\u00b0 A\n", + "(ii) Input power , P_i = 646.10 W\n", + "(iii) Power developed , P_d = 275.8 W\n", + "(iv) Torque developed , T_d = 1.76 N-m\n", + "\n", + "NOTE : Case(ii) is not solved in textbook but solved here\n", + " ERROR : Calculation mistake in Z_b in textbook solution\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.3, Page number 363-364" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "V_t = 220.0 #Supply voltage(V)\n", + "f = 50.0 #Frequency(Hz)\n", + "Z_m = complex(3,5) #Main winding impedance of motor(ohm)\n", + "Z_s = complex(5,3) #Starting impedance of motor(ohm)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "alpha_s = cmath.phase(Z_s) #Starting winding impedance angle(radians)\n", + "I_s = V_t/Z_s #Starting current(A)\n", + "#For case(ii)\n", + "alpha_m = cmath.phase(Z_m) #Main winding impedance angle(radians)\n", + "I_m = V_t/Z_m #Main winding current(A)\n", + "#For case(iii)\n", + "a = alpha_m-alpha_s #Angle of line current(radians)\n", + "I = (abs(I_s)**2+abs(I_m)**2+2*abs(I_s)*abs(I_m)*math.cos(a))**0.5 #Line current(A)\n", + "\n", + "#Result\n", + "print('(i) Starting current , I_s = %.1f\u2220%.2f\u00b0 A' %(abs(I_s),cmath.phase(I_s)*180/math.pi))\n", + "print('(ii) Main winding current , I_m = %.1f\u2220%.f\u00b0 A' %(abs(I_m),cmath.phase(I_m)*180/math.pi))\n", + "print('(iii) Line current , I = %.1f A' %I)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Starting current , I_s = 37.7\u2220-30.96\u00b0 A\n", + "(ii) Main winding current , I_m = 37.7\u2220-59\u00b0 A\n", + "(iii) Line current , I = 73.2 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.4, Page number 364" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "V_t = 220.0 #Supply voltage(V)\n", + "f = 50.0 #Frequency(Hz)\n", + "Z_m = complex(4,3.5) #Main winding impedance of motor(ohm)\n", + "Z_s = complex(5,3) #Starting impedance of motor(ohm)\n", + "\n", + "#Calculation\n", + "alpha_m = cmath.phase(Z_m) #Main winding impedance angle(radians)\n", + "alpha_s = (alpha_m)-(90*math.pi/180) #Angle of starting winding current(radians)\n", + "X_c = Z_s.imag-Z_s.real*math.tan(alpha_s) #Reactance connected in series with starting winding(ohm)\n", + "C = 1/(2*math.pi*f*X_c)*10**6 #Starting capacitance for getting maximum torque(\u00b5F)\n", + "\n", + "#Result\n", + "print('Starting capacitance for getting maximum torque , C = %.f \u00b5F' %C)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Starting capacitance for getting maximum torque , C = 365 \u00b5F\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.5, Page number 370-371" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "f = 50.0 #Supply frequency(Hz)\n", + "V_nl = 100.0 #No-load voltage(V)\n", + "I_nl = 2.5 #No-load current(A)\n", + "P_nl = 60.0 #No-load power(W)\n", + "V_br = 60.0 #Block rotor voltage(V)\n", + "I_br = 3.0 #Block rotor current(A)\n", + "P_br = 130.0 #Block rotor power(W)\n", + "R_1 = 2.0 #Main winding resistance(ohm)\n", + "\n", + "#Calculation\n", + "Z_br = V_br/I_br #Impedance due to blocked rotor test(ohm)\n", + "R_br = P_br/I_br**2 #Resistance due to blocked rotor test(ohm)\n", + "X_br = (Z_br**2-R_br**2)**0.5 #Reactance under blocked rotor condition(ohm)\n", + "X_1 = 0.5*X_br #Leakage reactance(ohm)\n", + "X_2 = X_1 #Leakage reactance(ohm)\n", + "R_2 = R_br-R_1 #Rotor circuit resistance(ohm)\n", + "Z_nl = V_nl/I_nl #Impedance due to no-load(ohm)\n", + "R_nl = P_nl/I_nl**2 #Resistance due to no-load(ohm)\n", + "X_nl = (Z_nl**2-R_nl**2)**0.5 #Reactance due to no-load(ohm)\n", + "X_m = 2*(X_nl-X_1-0.5*X_2) #Magnetizing reactance(ohm)\n", + "P_rot = P_nl-I_nl**2*(R_1+(R_2/4)) #Rotational loss(W)\n", + "\n", + "#Result\n", + "print('Equivalent circuit parameters of the motor')\n", + "print('Under Blocked rotor test :')\n", + "print('Input impedance , Z_br = %.f ohm' %Z_br)\n", + "print('Total resistance , R_br = %.1f ohm' %R_br)\n", + "print('Total reactance , X_br = %.1f ohm' %X_br)\n", + "print('Rotor circuit resistance , R_2 = %.1f ohm' %R_2)\n", + "print('Leakage reactances , X_1 = X_2 = %.1f ohm' %X_1)\n", + "print('\\nUnder No load test :')\n", + "print('Input impedance , Z_nl = %.f ohm' %Z_nl)\n", + "print('No-load resistance , R_nl = %.1f ohm' %R_nl)\n", + "print('No-load reactance , X_nl = %.1f ohm' %X_nl)\n", + "print('Magnetizing reactance , X_m = %.1f ohm' %X_m)\n", + "print('Rotational loss , P_rot = %.f W' %P_rot)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Equivalent circuit parameters of the motor\n", + "Under Blocked rotor test :\n", + "Input impedance , Z_br = 20 ohm\n", + "Total resistance , R_br = 14.4 ohm\n", + "Total reactance , X_br = 13.8 ohm\n", + "Rotor circuit resistance , R_2 = 12.4 ohm\n", + "Leakage reactances , X_1 = X_2 = 6.9 ohm\n", + "\n", + "Under No load test :\n", + "Input impedance , Z_nl = 40 ohm\n", + "No-load resistance , R_nl = 9.6 ohm\n", + "No-load reactance , X_nl = 38.8 ohm\n", + "Magnetizing reactance , X_m = 56.9 ohm\n", + "Rotational loss , P_rot = 28 W\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.6, Page number 372" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "r_t = 36.0 #Number of rotor teeth\n", + "N = 4.0 #Number of stator phases\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "T_p = 360/r_t #Tooth pitch(degree)\n", + "#For case(ii)\n", + "teta = 360/(N*r_t) #Step angle(degree)\n", + "\n", + "#Result\n", + "print('(i) Tooth pitch , T_p = %.f\u00b0 ' %T_p)\n", + "print('(ii) Step angle , \u03b8 = %.1f\u00b0 ' %teta)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Tooth pitch , T_p = 10\u00b0 \n", + "(ii) Step angle , \u03b8 = 2.5\u00b0 \n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_2.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_2.ipynb new file mode 100755 index 00000000..4a1c83c7 --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_2.ipynb @@ -0,0 +1,623 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 2: BASICS OF MAGNETIC CIRCUITS" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.1, Page number 53" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "l = 4.0 #Length(m)\n", + "w = 2.0 #Width(m)\n", + "B = 0.12 #Magnetic flux density(Tesla)\n", + "\n", + "#Calculation \n", + "A = l*w #Area(m^2)\n", + "flux = B*A #Magnetic flux(Wb)\n", + "\n", + "#Result\n", + "print('Magnetic flux , \u03a6 = %.2f Wb' %flux)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Magnetic flux , \u03a6 = 0.96 Wb\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.2, Page number 54" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "d_in = 3.0 #Inside diameter(cm)\n", + "d_out = 6.0 #Outside diameter(cm)\n", + "N = 200.0 #Number of turns\n", + "I = 3.0 #Current(A)\n", + "flux = 0.015 #Flux(Wb)\n", + "\n", + "#Calculation\n", + "d = d_in+(d_out-d_in)/2 #Distance(cm)\n", + "l = math.pi*d #Mean length of core(cm)\n", + "A = math.pi*d**2/4*10**-4 #Area(m^2)\n", + "B = flux/A #Flux density(Wb/m^2)\n", + "MMF = N*I #Magnetomotive force(At)\n", + "H = N*I/(l*10**-2) #Magnetic field intensity(At/m)\n", + "\n", + "#Result\n", + "print('Flux density , B = %.2f Wb/m^2' %B)\n", + "print('Magnetomotive force , MMF = %.1f At' %MMF)\n", + "print('Magnetic field intensity , H = %.2f At/m' %H)\n", + "print('\\nNOTE : ERROR : Calculation & unit mistakes in textbook')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Flux density , B = 9.43 Wb/m^2\n", + "Magnetomotive force , MMF = 600.0 At\n", + "Magnetic field intensity , H = 4244.13 At/m\n", + "\n", + "NOTE : ERROR : Calculation & unit mistakes in textbook\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.3, Page number 55" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "u_r = 625.0 #Relative permeability of rectangular core\n", + "N = 25.0 #Number of turns\n", + "I = 2.0 #Current(A)\n", + "a = 5.5 #Lenght of rectangular core(cm)\n", + "b = 1.5 #Width of rectangular core(cm)\n", + "\n", + "#Calculation\n", + "l = 2*(a+b) #Mean length of core(cm)\n", + "H = N*I/(l*10**-2) #Magnetic field intensity(At/m)\n", + "u_0 = 4*math.pi*10**-7 #Permeability of free space(H/m)\n", + "u = u_0*u_r #Permeabilty\n", + "B = u*H #Magnetic flux density(Wb/m^2)\n", + "\n", + "#Result\n", + "print('Magnetic field intensity , H = %.f At/m ' %H)\n", + "print('Permeabilty , \u00b5 = %.2e ' %u)\n", + "print('Magnetic flux density , B = %.2f Wb/m^2 ' %B)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Magnetic field intensity , H = 357 At/m \n", + "Permeabilty , \u00b5 = 7.85e-04 \n", + "Magnetic flux density , B = 0.28 Wb/m^2 \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.4, Page number 57" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "N = 6.0 #Number of turns\n", + "I = 3.0 #Current(A)\n", + "flux = 0.056 #Flux(Wb)\n", + "\n", + "#Calculation\n", + "MMF = N*I #Magnetomotive force(At)\n", + "R_m = MMF/flux #Reluctance(At/Wb)\n", + "\n", + "#Result\n", + "print('Magnetomotive force , MMF = %.f At' %MMF)\n", + "print('Reluctance , R_m = %.1f At/Wb' %R_m)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Magnetomotive force , MMF = 18 At\n", + "Reluctance , R_m = 321.4 At/Wb\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.5, Page number 59" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "I = 15.0 #Current through conductor(A)\n", + "N = 10.0 #Number of turns\n", + "u_0 = 4.0*math.pi*10**-7 #Permeability of free space(H/m)\n", + "u_r = 1.0 #Relative permeability of air medium\n", + "r = 0.015 #Distance(m)\n", + "\n", + "#Calculation\n", + "B = u_0*u_r*N*I/(2*math.pi*r) #Magnetic flux density(T)\n", + "\n", + "#Result\n", + "print('Magnetic flux density , B = %.1e T' %B)\n", + "print('\\nNOTE : ERROR : Distance is 1.5 cm & not 2.5 cm as given in textbook')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Magnetic flux density , B = 2.0e-03 T\n", + "\n", + "NOTE : ERROR : Distance is 1.5 cm & not 2.5 cm as given in textbook\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.6, Page number 60-61" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "N = 200.0 #Number of turns \n", + "d_in = 7.0 #Inner diameter(cm)\n", + "d_out = 10.0 #Outer diameter(cm)\n", + "A = 0.005 #Cross sectional area(m^2)\n", + "I = 5.0 #Current through coil(A)\n", + "\n", + "#Calculation\n", + "u_0 = 4.0*math.pi*10**-7 #Permeability of free space(H/m)\n", + "R = d_out-d_in\n", + "l = round(2*math.pi*R/100,2) #Mean circumference length(m)\n", + "#For case(i)\n", + "H = N*I/l #Magnetic field intensity(At/m)\n", + "#For case(ii)\n", + "B = u_0*H*1000 #Flux density(mWb/m^2)\n", + "#For case(iii)\n", + "flux = B*A*1000 #Flux(\u00b5Wb)\n", + "\n", + "#Result\n", + "print('Magnetic field intensity , H = %.1f At/m' %H)\n", + "print('Flux density , B = %.1f mWb/m^2' %B)\n", + "print('Flux , \u03a6 = %.f \u00b5Wb' %flux)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Magnetic field intensity , H = 5263.2 At/m\n", + "Flux density , B = 6.6 mWb/m^2\n", + "Flux , \u03a6 = 33 \u00b5Wb\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.7, Page number 62-63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "l = 0.1 #Length(m)\n", + "w = 0.01 #Width(m)\n", + "h = 0.1 #Height(m)\n", + "N = 450.0 #Number of turns\n", + "I = 0.2 #Current(A)\n", + "u_r = 850.0 #Relative permeability\n", + "\n", + "#Calculation\n", + "MMF = N*I #Magnetomotive force(At)\n", + "l_c = (h-w)*4 #Mean length of the path(m)\n", + "A = w*w #Cross sectional area(m^2)\n", + "u_0 = 4.0*math.pi*10**-7 #Permeability of free space(H/m)\n", + "R_m = l_c/(u_0*u_r*A) #Reluctance(At/Wb)\n", + "flux = MMF/R_m #Flux(Wb)\n", + "B = flux/A #Magnetic flux density(Wb/m^2)\n", + "H = B/(u_0*u_r) #Magnetic field intensity(At/m)\n", + "\n", + "#Result\n", + "print('Flux , \u03a6 = %.2e Wb' %flux)\n", + "print('Flux density , B = %.2f Wb/m^2' %B)\n", + "print('Field intensity , H = %.1f At/m' %H)\n", + "print('\\nNOTE : Changes in obtained answer from that of textbook is due to more precision')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Flux , \u03a6 = 2.67e-05 Wb\n", + "Flux density , B = 0.27 Wb/m^2\n", + "Field intensity , H = 250.0 At/m\n", + "\n", + "NOTE : Changes in obtained answer from that of textbook is due to more precision\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.8, Page number 64-65" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "N = 450.0 #Number of turns wound on left side of limb\n", + "A = 4.0 #Cross sectional area(m^2)\n", + "phi_2 = 3.0 #Flux(Wb) in the right limb\n", + "u_r = 500.0 #Relative permeability\n", + "l_1 = 0.12 #Length of middle limb(m)\n", + "l_2 = 0.24 #Length of right limb(m)\n", + "\n", + "#Calculation\n", + "u_0 = 4.0*math.pi*10**-7 #Permeability of free space(H/m)\n", + "phi_1 = phi_2*l_2/l_1 #Flux in middle limb(Wb)\n", + "phi = phi_1+phi_2 #Total flux(Wb)\n", + "B = phi/A #Flux density in the left limb(Wb/m^2)\n", + "H = B/(u_0*u_r) #Magnetic field intensity(At/m)\n", + "MMF = H*l_2 #Magnetomotive force(At)\n", + "B_2 = phi_2/A #Flux density in the right limb(Wb/m^2)\n", + "H_2 = B_2/(u_0*u_r) #Magnetic field(At/m)\n", + "MMF_2 = H_2*l_2 #Magnetomotive force(At)\n", + "MMF_t = MMF+MMF_2 #Total magnetomotive force(At)\n", + "I = MMF_t/N #Current(A)\n", + "\n", + "#Result\n", + "print('Current , I = %.2f A' %I)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Current , I = 2.55 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.9, Page number 67-68" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "l = 0.45 #Mean length(m)\n", + "A = 25.0*10**-4 #Cross sectional area(m^2)\n", + "l_g = 0.8*10**-3 #Length of air gap(m)\n", + "N = 500.0 #Number of turns \n", + "I = 1.25 #Current(A) \n", + "flux = 1.5*10**-3 #Flux(Wb)\n", + "\n", + "#Calculation\n", + "u_0 = 4.0*math.pi*10**-7 #Permeability of free space(H/m)\n", + "B = flux/A #Magnetic flux density(Wb/m^2)\n", + "MMF = N*I #Magnetomotive force(At)\n", + "R_m = MMF/flux #Reluctance(At/Wb)\n", + "H = B/u_0 #Magnetizing force(At/m)\n", + "MMF_ag = H*l_g #Magnetomotive force(At)\n", + "MMF_i = MMF-MMF_ag #Magnetomotive force for iron ring(At)\n", + "H_i = MMF_i/l #Magnetic field intensity for iron part(At/m)\n", + "u_r = B/(u_0*H_i) #Relative permeability for iron\n", + "\n", + "#Result\n", + "print('Reluctance , R_m = %.2e At/Wb' %R_m)\n", + "print('Relative permeability of the iron ring iron , \u00b5_r = %.f ' %u_r)\n", + "print('\\nNOTE : Reluctance part is not solved in textbook')\n", + "print('ERROR : Current is 1.25A not 2.25A & flux is 1.5 mWb not 2.5 mWb as given in textbook')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Reluctance , R_m = 4.17e+05 At/Wb\n", + "Relative permeability of the iron ring iron , \u00b5_r = 884 \n", + "\n", + "NOTE : Reluctance part is not solved in textbook\n", + "ERROR : Current is 1.25A not 2.25A & flux is 1.5 mWb not 2.5 mWb as given in textbook\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.10, Page number 68" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "A = 2.0*10**-4 #Cross sectional area(m^2)\n", + "N = 200.0 #Number of turns \n", + "flux = 1.5*10**-3 #Flux(Wb)\n", + "u_r = 4000.0 #Relative permeability of core\n", + "l_g = 0.01 #Length of air gap(m)\n", + "a = 9.0 #Length(cm)\n", + "w = 3.0 #Width(cm)\n", + "\n", + "#Calculation\n", + "u_0 = 4.0*math.pi*10**-7 #Permeability of free space(H/m)\n", + "R_mg = l_g/(u_0*A) #Reluctance of air gap(At/Wb)\n", + "l = 4*(a-w-w+(1.5+1.5))-1 #Mean length of iron(cm)\n", + "u = u_0*u_r #Permeability\n", + "R_mi = l*10**-2/(u*A) #Reluctance of iron(At/Wb)\n", + "R_mt = R_mg+R_mi #Total reluctance(At/Wb)\n", + "I = R_mt*flux/N #Current(A)\n", + "\n", + "#Result\n", + "print('Total reluctance , R_mt = %.3e AT/Wb' %R_mt)\n", + "print('Current flowing through the coil , I = %.1f A' %I)\n", + "print('\\nNOTE : ERROR : Total flux is 1.5 mWB & not 2.5 mWB as given in textbook question')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total reluctance , R_mt = 4.002e+07 AT/Wb\n", + "Current flowing through the coil , I = 300.1 A\n", + "\n", + "NOTE : ERROR : Total flux is 1.5 mWB & not 2.5 mWB as given in textbook question\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.11, Page number 70" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "I = 150.0 #Current through conductor(A)\n", + "l = 2.0 #Conductor length(m)\n", + "B = 0.35 #Magnetic flux density(T)\n", + "\n", + "#Calculation\n", + "F = B*l*I #Force(N)\n", + "\n", + "#Result\n", + "print('Force , F = %.f N' %F)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Force , F = 105 N\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.12, Page number 76" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "l = 25.0*10**-2 #Length of air-core coil(m)\n", + "A = 4.0*10**-4 #Cross sectional area(m^2)\n", + "N = 65.0 #Number of turns\n", + "\n", + "#Calculation\n", + "u_0 = 4.0*math.pi*10**-7 #Permeability of free space(H/m)\n", + "u_r = 1.0\n", + "u = u_0*u_r #Permeability\n", + "L = N**2*u*A/l*10**6 #Inductance(\u00b5H)\n", + "\n", + "#Result\n", + "print('Inductance of the coil , L = %.1f \u00b5H' %L)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inductance of the coil , L = 8.5 \u00b5H\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.13, Page number 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "k_h = 110.0 #Hysteresis co-efficient(J/m^3)\n", + "V_cvol = 0.005 #Volume of core(m^3)\n", + "B_m = 1.12 #Maximum flux density(T)\n", + "f = 60.0 #Frequency(Hz)\n", + "n = 1.6\n", + "\n", + "#Calculation\n", + "P_h = k_h*V_cvol*B_m**n*f #Hysteresis loss(W)\n", + "\n", + "#Result\n", + "print('Hysteresis loss , P_h = %.2f W' %P_h)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Hysteresis loss , P_h = 39.56 W\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_3.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_3.ipynb new file mode 100755 index 00000000..68c7ac6d --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_3.ipynb @@ -0,0 +1,883 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 3: TRANSFORMER AND PER UNIT SYSTEM" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.1, Page number 90-91" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_1 = 2200.0 #Primary voltage of transformer(V)\n", + "V_2 = 220.0 #Secondary voltage of transformer(V)\n", + "N_2 = 56.0 #Number of turns in the secondary coil of transformer\n", + "kVA = 25.0 #Rating of transformer(kVA)\n", + "\n", + "#Calculation\n", + "a = V_1/V_2 #Turns ratio\n", + "#For case(i)\n", + "N_1 = a*N_2 #Number of primary turns\n", + "#For case(ii)\n", + "I_1 = kVA*10**3/V_1 #Primary full load current(A)\n", + "#For case(iii)\n", + "I_2 = kVA*10**3/V_2 #Secondary full load current(A)\n", + "\n", + "#Result\n", + "print('(i) Number of primary turns , N_1 = %.f ' %N_1)\n", + "print('(ii) Primary full load current , I_2 = %.2f A' %I_1)\n", + "print('(iii) Secondary full load current , I_2 = %.1f A' %I_2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Number of primary turns , N_1 = 560 \n", + "(ii) Primary full load current , I_2 = 11.36 A\n", + "(iii) Secondary full load current , I_2 = 113.6 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.2, Page number 91" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_1 = 220.0 #Voltage(V)\n", + "N_1 = 150.0 #Number of turns in primary side\n", + "N_2 = 300.0 #Number of turns in secondary side\n", + "f = 50.0 #Frequency(Hz)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "a = N_1/N_2 #Turns ratio\n", + "#For case(ii)\n", + "phi_m = V_1/(4.44*f*N_1)*10**3 #Mutual flux(mWb)\n", + "\n", + "#Result\n", + "print('(i) Turns ratio , a = %.1f ' %a)\n", + "print('(ii) Mutual flux in the core , \u03a6_m = %.2f mWb' %phi_m)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Turns ratio , a = 0.5 \n", + "(ii) Mutual flux in the core , \u03a6_m = 6.61 mWb\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.3, Page number 92" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "V_1 = 2200.0 #Primary voltage(V)\n", + "V_2 = 220.0 #Secondary voltage(V)\n", + "I_0 = 0.5 #No-load current(A)\n", + "P_0 = 350.0 #Power absorbed(W)\n", + "\n", + "#Calculation\n", + "cos_phi_0 = P_0/(V_1*I_0) #No-load power factor\n", + "I_w = I_0*cos_phi_0 #Iron loss component of current(A)\n", + "phi_0 = math.acos(cos_phi_0) #Power factor angle\n", + "I_m = I_0*math.sin(phi_0) #Magnetizing component of current(A)\n", + "\n", + "#Result\n", + "print('Iron loss component of current , I_w = %.2f A' %I_w)\n", + "print('Magnetizing component of current , I_m = %.2f A' %I_m)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Iron loss component of current , I_w = 0.16 A\n", + "Magnetizing component of current , I_m = 0.47 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.4, Page number 94" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "N_1 = 450.0 #Number of turns in the primary side\n", + "N_2 = 45.0 #Number of turns in the secondary side\n", + "Z_L = 3.0 #Load impedance(ohm)\n", + "V_1 = 15.0 #Primary coil voltage of transformer(V)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "a = N_1/N_2 #Turns ratio\n", + "#For case(ii)\n", + "Z_1 = a**2*Z_L #Load impedance referred to primary(ohm)\n", + "#For case(iii)\n", + "I_1 = V_1/Z_1 #Primary current(A)\n", + "\n", + "#Result\n", + "print('(i) Turns ratio , a = %.f ' %a)\n", + "print('(ii) Load impedance referred to primary , Z_1 = %.f ohm' %Z_1)\n", + "print('(iii) Primary current , I_1 = %.2f A' %I_1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Turns ratio , a = 10 \n", + "(ii) Load impedance referred to primary , Z_1 = 300 ohm\n", + "(iii) Primary current , I_1 = 0.05 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.5, Page number 96-97" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "V_1 = 400.0 #Primary voltage of transformer(V)\n", + "V_2 = 100.0 #Secondary voltage of transformer(V)\n", + "I_0 = 0.4 #No-load current(A)\n", + "I_2 = 100.0 #Current drawn by load(A)\n", + "cos_phi_0 = 0.3 #Power factor lagging from the supply\n", + "cos_phi_2 = 0.6 #Power factor lagging from the secondary\n", + "\n", + "#Calculation\n", + "phi_0 = math.acos(cos_phi_0) #Power factor angle(radians)\n", + "phi_0_deg = phi_0*180/math.pi #Power factor angle(degree)\n", + "phi_2 = math.acos(cos_phi_2) #Power factor angle(radians)\n", + "phi_2_deg = phi_2*180/math.pi #Power factor angle(degree)\n", + "phi_1 = phi_0-phi_2 #Angle(radians)\n", + "phi_1_deg = phi_1*180/math.pi #Angle(degree)\n", + "a = V_1/V_2 #Turns ratio\n", + "I_2_ = I_2/a #Secondary current equivalent to the primary(A) \n", + "I_1 = ((I_2_**2)+(I_0**2)+(2*I_2_*I_0*math.cos(phi_1)))**0.5 #Primary current(A)\n", + "\n", + "#Result\n", + "print('Primary current , I_1 = %.1f A' %I_1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Primary current , I_1 = 25.4 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.6, Page number 101" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_1 = 2000.0 #Primary voltage of transformer(V)\n", + "V_2 = 400.0 #Secondary voltage of transformer(V)\n", + "kVA = 200.0 #Rating of transformer(kVA)\n", + "R_1 = 3.0 #Primary resistance(ohm)\n", + "X_1 = 12.0 #Primary reactance(ohm)\n", + "R_2 = 0.3 #Secondary resistance(ohm)\n", + "X_2 = 0.1 #Secondary reactance(ohm)\n", + "\n", + "#Calculation\n", + "a = V_1/V_2 #Turns ratio\n", + "R_01 = R_1+(a**2*R_2) #Total resistance referred to primary(ohm)\n", + "X_01 = X_1+(a**2*X_2) #Total reactance referred to primary(ohm)\n", + "Z_01 = ((R_01**2)+(X_01**2))**0.5 #Equivalent impedance referred to primary(ohm)\n", + "R_02 = R_2+(R_1/a**2) #Total resistance referred to secondary side(ohm)\n", + "X_02 = X_2+(X_1/a**2) #Total reactance referred to secondary side(ohm)\n", + "Z_02 = ((R_02**2)+(X_02**2))**0.5 #Equivalent impedance referred to secondary side(ohm)\n", + "\n", + "#Result\n", + "print('Equivalent impedance referred to primary , Z_01 = %.1f ohm' %Z_01)\n", + "print('Equivalent impedance referred to secondary , Z_02 = %.2f ohm' %Z_02)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Equivalent impedance referred to primary , Z_01 = 17.9 ohm\n", + "Equivalent impedance referred to secondary , Z_02 = 0.72 ohm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.7, Page number 103-104" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "V_1 = 200.0 #Primary voltage(V)\n", + "V_2 = 400.0 #Secondary voltage(V)\n", + "R_1 = 0.3 #Primary resistance(ohm)\n", + "X_1 = 0.6 #Primary reactance(ohm)\n", + "R_2 = 0.8 #Secondary resistance(ohm)\n", + "X_2 = 1.6 #Secondary reactance(ohm)\n", + "I_2 = 10.0 #Secondary supply current(A)\n", + "cos_phi_2 = 0.8 #Power factor lagging\n", + "\n", + "#Calculation\n", + "a = V_1/V_2 #Turns ratio\n", + "R_02 = R_2+(R_1/a**2) #Total resistance referred to secondary(ohm)\n", + "X_02 = X_2+(X_1/a**2) #Total reactance referred to primary(ohm)\n", + "sin_phi_2 = math.sin(math.acos(cos_phi_2))\n", + "E_2 = complex((V_2*cos_phi_2+I_2*R_02),(V_2*sin_phi_2+I_2*X_02)) #No-load voltage(V)\n", + "V_reg = (abs(E_2)-V_2)/V_2*100 #Voltage regulation(percent)\n", + "\n", + "#Result\n", + "print('Voltage regulation = %.f percent' %V_reg)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage regulation = 10 percent\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.8, Page number 105-106" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P_i = 1.0 #Iron loss of transformer(kW)\n", + "P_cu = 2.0 #Full load copper loss of transformer(kW)\n", + "kVA = 200.0 #Rating of transformer(kVA)\n", + "pf_1 = 1.0 #Power factor\n", + "pf_2 = 0.95 #Power factor\n", + "\n", + "#Calculation\n", + "P_cu1 = (3.0/4)**2*P_cu #Copper loss at 3/4 full load(kW)\n", + "P_cu2 = (1.0/2)**2*P_cu #Copper loss at 1/2 full load(kW)\n", + "P_01 = (3.0/4)*kVA*pf_1 #Output power at 3/4 full load and unity pf(kW)\n", + "P_in1 = P_01+P_i+P_cu1 #Input power at 3/4 full load and unity pf(kW)\n", + "n_1 = (P_01/P_in1)*100 #Efficiency at 3/4 full load and unity pf(percent)\n", + "P_02 = (1.0/2)*kVA*pf_2 #Output power at 1/2 full load and 0.95 pf(kW)\n", + "P_in2 = P_02+P_i+P_cu2 #Input power at 1/2 full load and 0.95 pf(kW)\n", + "n_2 = (P_02/P_in2)*100 #Efficiency at 1/2 full load and 0.95 pf(percent)\n", + "\n", + "#Result\n", + "print('Efficiency at 3/4 full load and unity power factor , \u03b7_1 = %.2f percent' %n_1)\n", + "print('Efficiency at 1/2 full load and 0.95 power factor , \u03b7_2 = %.2f percent' %n_2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency at 3/4 full load and unity power factor , \u03b7_1 = 98.60 percent\n", + "Efficiency at 1/2 full load and 0.95 power factor , \u03b7_2 = 98.45 percent\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.9, Page number 108" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P_i = 350.0 #Iron loss of transformer(W)\n", + "P_cu = 650.0 #Full load copper loss of transformer(W)\n", + "kVA = 30.0 #Rating of transformer(kVA)\n", + "pf = 0.6 #Power factor\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "P_tloss = (P_i+P_cu)*10**-3 #Total full load loss(kW)\n", + "P_out = kVA*pf #Output power at full load(kW)\n", + "P_in = P_out+P_tloss #Input power at full load(kW)\n", + "n_1 = (P_out/P_in)*100 #Efficiency at full load(percent)\n", + "#For case(ii)\n", + "kVA_out = kVA*(P_i/P_cu)**0.5 #Output kVA corresponding to maximum efficiency(kVA) \n", + "P_01 = kVA_out*pf #Output power(kW)\n", + "#For case(iii)\n", + "P_tloss1 = 2*P_i*10**-3 #Total loss(kW)\n", + "P_in1 = P_01+P_tloss1 #Input power(kW)\n", + "n_2 = (P_01/P_in1)*100 #Efficiency(percent)\n", + "\n", + "#Result\n", + "print('(i) Full load efficiency , \u03b7 = %.2f percent' %n_1)\n", + "print('(ii) Output kVA corresponding to maximum efficiency = %.1f kVA' %kVA_out)\n", + "print('(iii) Maximum efficiency , \u03b7 = %.2f percent' %n_2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Full load efficiency , \u03b7 = 94.74 percent\n", + "(ii) Output kVA corresponding to maximum efficiency = 22.0 kVA\n", + "(iii) Maximum efficiency , \u03b7 = 94.97 percent\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.10, Page number 109-110" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "kVA = 12.0 #Rating of transformer(kVA)\n", + "n = 0.97 #Maximum efficiency at unity pf\n", + "pf = 1.0 #Power factor\n", + "t_1 = 8.0 #Time(hours)\n", + "P_1 = 10.0 #Load(kW)\n", + "pf_1 = 0.8 #Lagging power factor\n", + "t_2 = 10.0 #Time(hours)\n", + "P_2 = 15.0 #Load(kW)\n", + "pf_2 = 0.90 #Leading power factor\n", + "t_3 = 6.0 #Time at no-load(hours)\n", + "P_3 = 0 #Load(kW)\n", + "\n", + "#Calculation\n", + "P_01 = kVA*pf #Output power at full load and unity pf(kW)\n", + "P_in1 = P_01/n #Input power at full load(kW)\n", + "P_tloss = P_in1-P_01 #Total loss(kW)\n", + "P_cu = P_tloss/2 #Copper loss at 12 kVA(kW)\n", + "P_024 = P_1*t_1+P_2*t_2+P_3*t_3 #All-day output power(kWh)\n", + "P_i24 = 24*P_cu #Iron loss for 24 hours(kWh)\n", + "P_cu24 = P_cu*t_1*((P_1/pf_1)/kVA)**2+P_cu*t_2*((P_2/pf_2)/kVA)**2 #Copper loss for 24 hours(kW)\n", + "P_in24 = P_024+P_i24+P_cu24 #All day input power(kWh)\n", + "n_allday = (P_024/P_in24)*100 #All day efficiency(percent)\n", + "\n", + "#Result\n", + "print('All-day efficiency , \u03b7_allday = %.1f percent' %n_allday)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "All-day efficiency , \u03b7_allday = 96.0 percent\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.11, Page number 111" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "V_1 = 200.0 #Voltage(V)\n", + "f = 50.0 #Frequency(Hz)\n", + "I_0 = 0.6 #Current(A)\n", + "P_0 = 80.0 #Power(W)\n", + "\n", + "#Calculation\n", + "cos_phi_0 = P_0/(V_1*I_0) #Power factor\n", + "sin_phi_0 = math.sin(math.acos(cos_phi_0))\n", + "I_w = I_0*cos_phi_0 #Working component of no-load current(A)\n", + "I_m = I_0*sin_phi_0 #Magnetizing component of no-load current(A)\n", + "R_0 = V_1/I_w #No-load circuit resistance(ohm)\n", + "X_0 = V_1/I_m #No-load circuit reactance(ohm)\n", + "\n", + "#Result\n", + "print('No-load circuit resistance , R_0 = %.1f ohm' %R_0)\n", + "print('No-load circuit reactance , X_0 = %.1f ohm' %X_0)\n", + "print('\\nNOTE : Changes in obtained answer from that of textbook is due to more precision')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "No-load circuit resistance , R_0 = 500.0 ohm\n", + "No-load circuit reactance , X_0 = 447.2 ohm\n", + "\n", + "NOTE : Changes in obtained answer from that of textbook is due to more precision\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.12, Page number 112-113" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "kVA = 25.0 #Rating of transformer(kVA)\n", + "V1 = 2200.0 #Voltage at low-voltage primary side(V)\n", + "V2 = 220.0 #Voltage at low-voltage secondary side(V)\n", + "V_1 = 40.0 #Voltage at h.v side(V)\n", + "I_1 = 5.0 #Current at high voltage side(A)\n", + "P = 150.0 #Power at high voltage side(W)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "Z_01 = V_1/I_1 #Equivalent impedance referred to primary(ohm)\n", + "R_01 = P/I_1**2 #Equivalent resistance referred to primary(ohm)\n", + "phi = math.acos(R_01/Z_01) #Power factor angle(radians)\n", + "phi_deg = phi*180/math.pi #Power factor angle(degree)\n", + "X_01 = Z_01*math.sin(phi) #Equivalent reactance referred to primary(ohm)\n", + "#For case(ii)\n", + "a = V1/V2 #Turns ratio\n", + "Z_02 = Z_01/a**2 #Equivalent impedance referred to secondary(ohm)\n", + "R_02 = R_01/a**2 #Equivalent resistance referred to secondary(ohm)\n", + "X_02 = X_01/a**2 #Equivalent reactance referred to secondary(ohm)\n", + "#For case(iii)\n", + "I_2 = kVA*10**3/V2 #Secondary side current(A)\n", + "E_2 = V2+I_2*Z_02 #Secondary induced voltage(V)\n", + "VR = (E_2-V2)/V2*100 #Voltage regulation(percent)\n", + "\n", + "#Result\n", + "print('Case(i)')\n", + "print(' Equivalent resistance referred to primary , R_01 = %.1f ohm' %R_01)\n", + "print(' Equivalent reactance referred to primary , X_01 = %.1f ohm' %X_01)\n", + "print(' Equivalent impedance referred to primary , Z_01 = %.1f ohm' %Z_01)\n", + "print('\\nCase(ii)')\n", + "print(' Equivalent resistance referred to secondary , R_02 = %.2f ohm' %R_02)\n", + "print(' Equivalent reactance referred to secondary , X_02 = %.3f ohm' %X_02)\n", + "print(' Equivalent impedance referred to secondary , Z_02 = %.2f ohm' %Z_02)\n", + "print('\\nCase(iii)')\n", + "print(' Voltage regulation , VR = %.1f percent' %VR)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Case(i)\n", + " Equivalent resistance referred to primary , R_01 = 6.0 ohm\n", + " Equivalent reactance referred to primary , X_01 = 5.3 ohm\n", + " Equivalent impedance referred to primary , Z_01 = 8.0 ohm\n", + "\n", + "Case(ii)\n", + " Equivalent resistance referred to secondary , R_02 = 0.06 ohm\n", + " Equivalent reactance referred to secondary , X_02 = 0.053 ohm\n", + " Equivalent impedance referred to secondary , Z_02 = 0.08 ohm\n", + "\n", + "Case(iii)\n", + " Voltage regulation , VR = 4.1 percent\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.13, Page number 114-115" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "kVA = 120.0 #Rating of autotransformer(kVA)\n", + "V1 = 220.0 #Volteage at upper part of coil(V)\n", + "V2 = 2200.0 #Volteage at lower part of coil(V)\n", + "\n", + "#Calculation\n", + "I_pq = kVA*10**3/V1 #Current of upper winding(A)\n", + "I_qr = kVA*10**3/V2 #Current of lower winding(A)\n", + "I_1 = I_pq+I_qr #Current in primary side(A)\n", + "V_2 = V1+V2 #Voltage across the secondary side(V)\n", + "kVA_1 = I_1*V2/1000 #Rating of autotransformer(kVA)\n", + "kVA_2 = I_pq*V_2/1000 #Rating of autotransformer(kVA)\n", + " \n", + "\n", + "#Result\n", + "print('kVA ratings of the autotransformer')\n", + "print('\\t kVA_1 = %.f kVA' %kVA_1)\n", + "print('\\t kVA_2 = %.f kVA' %kVA_2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "kVA ratings of the autotransformer\n", + "\t kVA_1 = 1320 kVA\n", + "\t kVA_2 = 1320 kVA\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.14, Page number 119" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "kVA_1 = 100.0 #Rating of transformer(kVA)\n", + "kVA_2 = 200.0 #Rating of transformer(kVA)\n", + "E_1 = 500.0 #Secondary induced voltage in 100 kVA transformer(V)\n", + "E_2 = 450.0 #Secondary induced voltage in 200 kVA transformer(V)\n", + "Z_1 = 0.05 #Impedance of 100 kVA transformer\n", + "Z_2 = 0.08 #Impedance of 200 kVA transformer\n", + "\n", + "#Calculation\n", + "Z1 = Z_1*E_1/(kVA_1*10**3/E_1) #Actual impedance of first transformer(ohm)\n", + "Z2 = Z_2*E_2/(kVA_1*10**3/E_2) #Actual impedance of second transformer(ohm)\n", + "I_c = (E_1-E_2)/complex(0,Z1+Z2) #Circulating current(A)\n", + "\n", + "#Result\n", + "print('Circulating current , I_c = %.2f\u2220%.f\u00b0 A' %(abs(I_c),cmath.phase(I_c)*180/math.pi))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Circulating current , I_c = 174.22\u2220-90\u00b0 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.15, Page number 125" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_L1 = 11.0 #Supply voltage(kV)\n", + "I_P1 = 6.0 #Current drawn by transformer(A)\n", + "a = 11.0 #Turns ratio\n", + "\n", + "#Calculation\n", + "#For delta-wye connections\n", + "V_dP1 = V_L1 #Phase voltage at primary side(kV)\n", + "V_dP2 = V_dP1*10**3/a #Phase voltage at secondary side(V)\n", + "V_dL2 = 3**0.5*V_dP2 #Line voltage at secondary side(V)\n", + "I_dP1 = a/3**0.5 #Phase current in the primary(A)\n", + "I_dL2 = a*I_dP1 #Line current in secondary(A)\n", + "#For Wye-delta connection \n", + "V_wP1 = V_L1*10**3/3**0.5 #Phase voltage at primary side(V)\n", + "V_wP2 = V_wP1/a #Phase voltage at secondary(V)\n", + "V_wL2 = V_wP2 #Line voltage at secondary(V)\n", + "I_wP2 = a*I_P1 #Phase current in secondary(A)\n", + "I_wL2 = 3**0.5*I_wP2 #Line current in secondary(A)\n", + "\n", + "#Result\n", + "print('For delta-wye connection')\n", + "print(' (i) Line voltage at secondary side , V_L2 = %.f V' %V_dL2)\n", + "print(' (ii) Line current in the secondary , I_L2 = %.2f A' %I_dL2)\n", + "print('\\nFor wye-delta connection')\n", + "print(' (i) Line voltage at secondary side , V_L2 = %.2f V' %V_wL2)\n", + "print(' (ii) Line current in the secondary , I_L2 = %.2f A' %I_wL2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For delta-wye connection\n", + " (i) Line voltage at secondary side , V_L2 = 1732 V\n", + " (ii) Line current in the secondary , I_L2 = 69.86 A\n", + "\n", + "For wye-delta connection\n", + " (i) Line voltage at secondary side , V_L2 = 577.35 V\n", + " (ii) Line current in the secondary , I_L2 = 114.32 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.16, Page number 132" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "V_b = 220.0 #Voltage(V)\n", + "f = 50.0 #Frequency(Hz)\n", + "S_b = 600.0 #Base value of rating(VA)\n", + "R = 3.0 #Resistance(ohm)\n", + "X_L = 5.0 #Inductance(ohm)\n", + "Z = complex(R,X_L) #Impedance(ohm)\n", + "\n", + "#Calculation\n", + "I_b = S_b/V_b #Base value of current(A)\n", + "Z_b = V_b**2/S_b #Base impedance(ohm)\n", + "R_pu = R/Z_b #Per unit value of resistance\n", + "X_Lpu = X_L/Z_b #Per unit value of inductance\n", + "Z_pu = complex(R_pu,X_Lpu) #Per unit of value of impedance\n", + "Z_pu_alt = abs(Z)/Z_b #Per unit of value of impedance-alternative method\n", + "\n", + "#Result\n", + "print('Per unit value of resistance , R_pu = %.3f ' %R_pu)\n", + "print('Per unit value of inductance , X_Lpu = %.3f ' %X_Lpu)\n", + "print('Per unit of value of impedance , Z_pu = %.3f\u2220%.2f\u00b0 ' %(abs(Z_pu),cmath.phase(Z_pu)*180/math.pi))\n", + "print('Per unit of value of impedance by alternative method , Z_pu = %.3f ' %Z_pu_alt)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Per unit value of resistance , R_pu = 0.037 \n", + "Per unit value of inductance , X_Lpu = 0.062 \n", + "Per unit of value of impedance , Z_pu = 0.072\u222059.04\u00b0 \n", + "Per unit of value of impedance by alternative method , Z_pu = 0.072 \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.17, Page number 132-134" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "MVA_T1 = 100.0 #Rating of transformer T1(MVA)\n", + "V_T1_hv = 220.0 #Voltage of h.v side of T1(kV)\n", + "V_T1_lv = 132.0 #Voltage of l.v side of T1(kV)\n", + "X_T1 = 0.2 #Impedance of T1(pu)\n", + "MVA_T2 = 50.0 #Rating of transformer T2(MVA)\n", + "V_T2_hv = 132.0 #Voltage of h.v side of T2(kV)\n", + "V_T2_lv = 66.0 #Voltage of l.v side of T2(kV)\n", + "X_T2 = 0.05 #Impedance of T2(pu)\n", + "X_L = 4.0 #Line impedance(ohm)\n", + "P = 50.0 #Power absorbed(MW)\n", + "pf = 0.6 #Lagging power factor\n", + "\n", + "#Calculation\n", + "S_b = MVA_T1 #Base apparent power(MW)\n", + "V_b = V_T1_hv #Base voltage(kV)\n", + "a = V_T1_hv/V_T1_lv #Turns ratio for first transformer\n", + "V_bline = V_T1_hv/a #Base voltage of line(kV)\n", + "Z_bline = V_bline**2/S_b #Base impedance of line(ohm)\n", + "X_puline = X_L/Z_bline #Per unit reactance of line\n", + "X_pu_T1 = X_T1*(V_T1_hv/V_b)**2*(S_b/MVA_T1) #Per unit reactance of first transformer\n", + "V_bload = V_T2_hv/(V_T2_hv/V_T2_lv) #Load side base voltage(kV)\n", + "X_pu_load = X_T2*(V_T2_lv/V_bload)**2*(S_b/MVA_T2) #Per unit reactance of second transformer\n", + "I_b = S_b*1000/(3**0.5*V_bload) #Base current at the load(A)\n", + "I_L = MVA_T2*1000/(3**0.5*V_T2_lv*pf) #Actual current in load(A)\n", + "I_Lpu = I_L/I_b #Per unit value of load current(pu)\n", + "V_L = V_T2_lv/V_bload #Per unit value of voltage at the load terminal(pu)\n", + "V_gb = I_Lpu*cmath.exp(1j*math.acos(pf))*complex(0,X_T1+X_puline+X_pu_load)+V_L #Per unit value of grid to bus voltage(pu)\n", + "V_gba = V_gb*V_T1_hv #Actual value of grid to bus voltage(kV)\n", + "\n", + "#Result\n", + "print('Grid to bus voltage , V_gb = %.f\u2220%.2f\u00b0 kV' %(abs(V_gba),cmath.phase(V_gba)*180/math.pi))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Grid to bus voltage , V_gb = 176\u222011.63\u00b0 kV\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_4.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_4.ipynb new file mode 100755 index 00000000..76dec5aa --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_4.ipynb @@ -0,0 +1,499 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 4: DIRECT CURRENT GENERATORS" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.1, Page number 143" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from sympy import *\n", + "\n", + "#Variable declaration\n", + "N = 100.0 #Number of turns\n", + "\n", + "#Calculation\n", + "t = Symbol('t')\n", + "e = N*diff(0.05*sin(314*t), t, 1)\n", + "\n", + "#Result\n", + "print('Induced voltage at the coil terminals , e = ' + repr(e) + ' V')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced voltage at the coil terminals , e = 1570.0*cos(314*t) V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.2, Page number 145" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "l = 0.65 #Length of conductor(m)\n", + "v = 35.0 #Speed of conductor(m/s)\n", + "B = 0.8 #Magnetic flux density(Tesla)\n", + "\n", + "#Calculation\n", + "e = B*l*v #Induced voltage at the conductor(V)\n", + "\n", + "#Result\n", + "print('Induced voltage at the conductor , e = %.1f V' %e)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced voltage at the conductor , e = 18.2 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.3, Page number 145" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "l = 1.5 #Length of conductor(m)\n", + "v = 20.0 #Velocity of conductor(m/s)\n", + "theta = 35.0*math.pi/180 #Angle(radians)\n", + "B = 0.9 #Magnetic flux density(Wb/m^2)\n", + "\n", + "#Calculation\n", + "e = B*l*v*math.sin(theta) #Induced voltage at the conductor(V)\n", + "\n", + "#Result\n", + "print('Induced voltage at the conductor , e = %.1f V' %e)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced voltage at the conductor , e = 15.5 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.4, Page number 152-153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P = 4.0 #Number of poles\n", + "S = 40.0 #Number of slots\n", + "C = 10.0 #Number of conductors per slot\n", + "phi = 0.02 #Flux per pole(Wb)\n", + "N = 1200.0 #Speed(rpm)\n", + "\n", + "#Calculation\n", + "Z = S*C #Total number of conductors\n", + "A = 2.0 #Number of parallel paths for Wave winding\n", + "E_g = P*phi*Z*N/(60*A) #Generated emf(V)\n", + "\n", + "#Result\n", + "print('Generated emf , E_g = %.f V' %E_g)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Generated emf , E_g = 320 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.5, Page number 153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P = 6.0 #Number of poles\n", + "Z = 600.0 #Number of conductors\n", + "phi = 0.05 #Flux per pole(Wb)\n", + "N = 1000.0 #Speed of generator(rpm)\n", + "I_a = 120.0 #Current supplied by generator(A)\n", + "\n", + "#Calculation\n", + "A = P #Number of parallel paths for lap winding\n", + "E_g = P*phi*Z*N/(60*A) #Generated voltage(V)\n", + "T_em = (P*Z*phi)/(2*math.pi*A)*I_a #Electromagnetic torque(N-m)\n", + "\n", + "\n", + "#Result\n", + "print('Generated voltage , E_g = %.f V' %E_g)\n", + "print('Electromagnetic torque , T_em = %.2f N-m' %T_em)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Generated voltage , E_g = 500 V\n", + "Electromagnetic torque , T_em = 572.96 N-m\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.6, Page number 156" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_t = 220.0 #Shunt generator voltage(V)\n", + "I_L = 250.0 #Load current(A)\n", + "R_sh = 50.0 #Shunt field resistance(ohm)\n", + "R_a = 0.02 #Armature resistance(ohm)\n", + "\n", + "#Calculation\n", + "I_sh = V_t/R_sh #Shunt field current(A)\n", + "I_a = I_L+I_sh #Armature current(A)\n", + "E_g = V_t+I_a*R_a #Generated voltage(V)\n", + "\n", + "#Result\n", + "print('Generated voltage , E_g = %.2f V' %E_g)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Generated voltage , E_g = 225.09 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.7, Page number 158-160" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "E = 25.0 #Power of compound generator(kW)\n", + "V_t = 220.0 #Terminal voltage(V)\n", + "R_a = 0.07 #Armature resistance(ohm)\n", + "R_se = 0.05 #Series resistance(ohm)\n", + "R_sh = 55.0 #Shunt field resistance(ohm)\n", + "V_brush = 1.0 #Voltage drop per brush(V)\n", + "\n", + "#Calculation\n", + "I_L = E*10**3/V_t #Load current in A\n", + "I_sh = V_t/R_sh #Shunt field current(A)\n", + "I_a = I_sh+I_L #Armature current(A)\n", + "#For case(i)\n", + "E_g1 = V_t+I_a*(R_a+R_se)+2*V_brush #Generated emf(V)\n", + "#For case(ii)\n", + "V_ab = V_t+I_L*R_se #Voltage across the shunt field(V)\n", + "I_sh2 = V_ab/R_sh #Current in the shunt field(A)\n", + "I_a2 = I_sh2+I_L #Armature current(A)\n", + "E_g2 = V_ab+I_a2*R_a+2*V_brush #Generated emf(V)\n", + "\n", + "#Result\n", + "print('(i) Generated emf when generator is connected in long shunt , E_g = %.f V' %E_g1)\n", + "print('(ii) Generated emf when generator is connected in short shunt , E_g = %.1f V' %E_g2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Generated emf when generator is connected in long shunt , E_g = 236 V\n", + "(ii) Generated emf when generator is connected in short shunt , E_g = 235.9 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.8, Page number 160-161" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_t = 220.0 #Shunt generator voltage(V)\n", + "I_L = 146.0 #Current delivered by generator(A)\n", + "R_sh = 55.0 #Shunt field resistance(ohm)\n", + "R_a = 0.012 #Armature resistance(ohm)\n", + "R_se = 0.02 #Series field resistance(ohm)\n", + "R_di = 0.03 #Diverter field resistance(ohm)\n", + "\n", + "#Calculation\n", + "I_sh = V_t/R_sh #Shunt field current(A)\n", + "I_a = I_L+I_sh #Armature current(A)\n", + "R_com = R_se*R_di/(R_se+R_di) #Combined resistance(ohm)\n", + "E_g = V_t+I_a*(R_a+R_com) #Generated voltage(V)\n", + "P_lsd = I_a**2*R_com #Power loss in series field and diverter(W)\n", + "P_la = I_a**2*R_a #Power loss in the armature circuit resistance(W)\n", + "P_lsh = V_t*I_sh #Power loss in shunt field resistance(W)\n", + "P_dl = I_L*V_t #Power delivered(W)\n", + "\n", + "#Result\n", + "print('Generated voltage , E_g = %.1f V' %E_g)\n", + "print('Power loss in the series field and diverter , P_lsd = %.1f W' %P_lsd)\n", + "print('Power loss in the armature circuit resistance , P_la = %.1f W' %P_la)\n", + "print('Power loss in the shunt field resistance , P_lsh = %.f W' %P_lsh)\n", + "print('Power delivered to the load , P_dl = %.f W' %P_dl)\n", + "print('\\nNOTE : ERROR : Shunt field resistance is taken as 50 ohm while solving I_sh in textbook but it is 55 ohm as per textbook question')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Generated voltage , E_g = 223.6 V\n", + "Power loss in the series field and diverter , P_lsd = 270.0 W\n", + "Power loss in the armature circuit resistance , P_la = 270.0 W\n", + "Power loss in the shunt field resistance , P_lsh = 880 W\n", + "Power delivered to the load , P_dl = 32120 W\n", + "\n", + "NOTE : ERROR : Shunt field resistance is taken as 50 ohm while solving I_sh in textbook but it is 55 ohm as per textbook question\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.9, Page number 169" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P = 4.0 #Number of poles\n", + "Z = 500.0 #Number of conductors\n", + "I_a = 30.0 #Current delivered by generator(A)\n", + "alpha = 6.0 #Angle at which brushes are displaced angle(degree)\n", + "\n", + "#Calculation\n", + "A = 2.0 #Number of parallel paths for Wave winding\n", + "I_c = I_a/A #Current per conductor(A)\n", + "#For case(i)\n", + "AT_d = Z*I_c*alpha/360 #Demagnetizing ampere-turns per pole(At)\n", + "#For case(ii)\n", + "AT_c = Z*I_c*((1/(2*P))-(alpha/360)) #Cross magnetizing ampere-turns per pole(At)\n", + "\n", + "#Result\n", + "print('(i) Demagnetizing ampere-turns , AT_d = %.f At' %AT_d)\n", + "print('(ii) Cross-magnetizing ampere-turns , AT_c = %.1f At' %AT_c)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Demagnetizing ampere-turns , AT_d = 125 At\n", + "(ii) Cross-magnetizing ampere-turns , AT_c = 812.5 At\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.10, Page number 176" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Power = 12.0 #Power(kW)\n", + "P = 4.0 #Number of poles\n", + "Z = 500.0 #Number of conductors\n", + "V_t = 250.0 #Generator voltage(V)\n", + "N = 1000.0 #Speed(rpm)\n", + "P_cu = 600 #Full load copper loss(W)\n", + "brush_drop = 2.0 #Total brush drop(V)\n", + "\n", + "#Calculation\n", + "A = P #Number of parallel paths for lap winding\n", + "I_a = Power*10**3/V_t #Armature current(A)\n", + "R_a = P_cu/I_a**2 #Armature resistance(ohm)\n", + "E_g = V_t+I_a*R_a+brush_drop #Generated voltage(V)\n", + "phi = E_g*60*A/(P*Z*N) #Flux per pole(Wb)\n", + "\n", + "#Result\n", + "print('Flux per pole , \u03a6 = %.3f Wb' %phi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Flux per pole , \u03a6 = 0.032 Wb\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.11, Page number 176-177" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P = 4.0 #Number of poles\n", + "I_L = 25.0 #Current delivered by generator(A)\n", + "V_t = 230.0 #Generator terminal voltage(V)\n", + "R_a = 0.2 #Armature resistance(ohm)\n", + "R_sh = 55.0 #Shunt field resistance(ohm)\n", + "V_brush = 1.0 #Voltage drop per brush(V)\n", + "\n", + "#Calculation\n", + "I_sh = V_t/R_sh #Shunt field current(A)\n", + "I_a = I_L+I_sh #Armature current(A)\n", + "E_g = V_t+I_a*R_a+2*V_brush #Induced voltage(V)\n", + "P_arm = E_g*I_a #Power generated in armature(W)\n", + "P_L = V_t*I_L #Power absorbed by load(W)\n", + "n = (P_L/P_arm)*100 #Efficiency(percent)\n", + "\n", + "#Result\n", + "print('Induced voltage , E_g = %.1f V' %E_g)\n", + "print('Efficiency of generator , \u03b7 = %.1f percent' %n)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced voltage , E_g = 237.8 V\n", + "Efficiency of generator , \u03b7 = 82.8 percent\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_5.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_5.ipynb new file mode 100755 index 00000000..27fbc256 --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_5.ipynb @@ -0,0 +1,435 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 5: DIRECT CURRENT MOTORS" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.1, Page number 182" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "l = 10.0 #Conductor length(m)\n", + "B = 0.56 #Magnetic flux density(T)\n", + "I = 2.0 #Current through conductor(A)\n", + "\n", + "#Calculation\n", + "F = B*I*l #Magnitude of force(N)\n", + "\n", + "#Result\n", + "print('Magnitude of force , F = %.1f N' %F)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Magnitude of force , F = 11.2 N\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.2, Page number 189" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "I = 20.0 #Total current(A)\n", + "V_t = 250.0 #Supply voltage(V) \n", + "R_sh = 200.0 #Shunt field resistance(ohm)\n", + "R_a = 0.3 #Armature resistance(ohm)\n", + "\n", + "#Calculation\n", + "I_sh = V_t/R_sh #Shunt field current(A)\n", + "I_a = I-I_sh #Armature current(A)\n", + "#For case(i)\n", + "E_b = V_t-R_a*I_a #Back emf(V)\n", + "#For case(ii)\n", + "P_md = E_b*I_a #Mechanical power developed(W) \n", + "\n", + "#Result\n", + "print('(i) Value of back emf , E_b = %.1f V' %E_b) \n", + "print('(ii) Mechanical power developed in the armature motor , P_md = %.1f W' %P_md)\n", + "print('\\nNOTE : ERROR : Armature current I_a = 18.13 A is taken in textbook solution instead of I_a = 18.75 A')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Value of back emf , E_b = 244.4 V\n", + "(ii) Mechanical power developed in the armature motor , P_md = 4582.0 W\n", + "\n", + "NOTE : ERROR : Armature current I_a = 18.13 A is taken in textbook solution instead of I_a = 18.75 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.3, Page number 189" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "R_a = 0.7 #Armature circuit resistance(ohm)\n", + "V_t = 5.0 #Applied voltage(V)\n", + "I_anl = 5.0 #No-load armature current(A)\n", + "I_afl = 35.0 #Full-load armature current(A)\n", + "\n", + "#Calculation\n", + "E_bnl = V_t-R_a*I_anl #Back emf under no-load(V)\n", + "E_bfl = V_t-R_a*I_afl #Back emf under full-load(V)\n", + "E_bc = E_bnl-E_bfl #Change in back emf from no-load to full load(V)\n", + " \n", + "#Result\n", + "print('Change in back emf from no-load to full load , E_bc = %.f V' %E_bc)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Change in back emf from no-load to full load , E_bc = 21 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.4, Page number 191" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "I = 40.0 #Current(A)\n", + "V_t = 230.0 #Supply voltage(V)\n", + "N = 1100.0 #Speed(rpm)\n", + "R_a = 0.25 #Armature resistance(ohm)\n", + "R_sh = 230.0 #Shunt field resistance(ohm) \n", + "\n", + "#Calculation\n", + "I_sh = V_t/R_sh #Shunt field current(A)\n", + "I_a = I-I_sh #Armature current(A)\n", + "E_b = V_t-I_a*R_a #Back emf(V) \n", + "T_a = 9.55*E_b*I_a/N #Armature torque(N-m)\n", + " \n", + "#Result\n", + "print('Torque developed by the armature , T_a = %.2f N-m' %T_a)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Torque developed by the armature , T_a = 74.57 N-m\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.5, Page number 191-192" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P = 6.0 #Number of poles\n", + "V_t = 230.0 #Supply voltage to shunt motor(V)\n", + "Z = 450.0 #Number of conductors\n", + "R_a = 0.8 #Armature resistance(ohm)\n", + "I = 30.0 #Current drawn from supply(A)\n", + "P_0 = 5560.0 #Output power(W)\n", + "I_f = 3.0 #Current through field winding(A)\n", + "phi = 25*10**-3 #Flux per pole(Wb)\n", + "\n", + "#Calculation\n", + "A = P #Number of parallel paths in lap winding\n", + "I_a = I-I_f #Armature current(A)\n", + "E_b = V_t-I_a*R_a #Back emf(V)\n", + "N = 60*A*E_b/(P*Z*phi) #Speed(rpm)\n", + "T_sh = 9.55*P_0/N #Shaft torque(N-m)\n", + "\n", + "#Result\n", + "print('Speed , N = %.1f rpm' %N)\n", + "print('Shaft torque , T_sh = %.1f N-m' %T_sh)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed , N = 1111.5 rpm\n", + "Shaft torque , T_sh = 47.8 N-m\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.6, Page number 193-194" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "I_Lnl = 5.0 #Current drawn at no-load(A)\n", + "V_t = 230.0 #Terminal voltage at no-load(V)\n", + "N_nl = 1000.0 #Speed at no-load(rpm)\n", + "R_a = 0.2 #Armature resistance(ohm)\n", + "R_f = 230.0 #Field resistance(ohm)\n", + "I_Lfl = 30.0 #Current drawn at full-load(A)\n", + "\n", + "#Calculation\n", + "#Under No-load condition\n", + "I_sh = V_t/R_f #Shunt field current(A)\n", + "I_a1 = I_Lnl-I_sh #Armature current(A)\n", + "E_b1 = V_t-I_a1*R_a #Back emf(V)\n", + "#Under Full-load condition\n", + "I_a2 = I_Lfl-I_sh #Armature current(A)\n", + "E_b2 = V_t-I_a2*R_a #Back emf(V)\n", + "N_2 = (E_b2/E_b1)*N_nl #Motor speed under load condition(rpm)\n", + "\n", + "#Result\n", + "print('Motor speed under load condition , N_2 = %.1f rpm' %N_2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Motor speed under load condition , N_2 = 978.2 rpm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.7, Page number 194-195" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "I_a1 = 65.0 #Current drawn(A)\n", + "V_t = 230.0 #Supply voltage(V)\n", + "N_1 = 900.0 #Speed(rpm)\n", + "R_a = 0.2 #Armature resistance(ohm)\n", + "R_sh = 0.25 #Field resistance(ohm)\n", + "I_a2 = 15.0 #Line current(A)\n", + "phi_1 = 1.0 #Assumtion of flux(Wb)\n", + "phi_2 = 0.4*phi_1 #Flux(Wb)\n", + "\n", + "#Calculation\n", + "E_b1 = V_t-I_a1*(R_a+R_sh) #Initial back emf(V)\n", + "E_b2 = V_t-I_a2*(R_a+R_sh) #Final back emf(V)\n", + "N_2 = N_1*E_b2*phi_1/(E_b1*phi_2) #Speed of motor(rpm)\n", + "\n", + "#Result\n", + "print('Speed of motor when line current is 15 A , N_2 = %.f rpm' %N_2)\n", + "print('\\nNOTE : ERROR : In textbook question current I_a1 = 56 A is given but it should be I_a1 = 65 A')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed of motor when line current is 15 A , N_2 = 2502 rpm\n", + "\n", + "NOTE : ERROR : In textbook question current I_a1 = 56 A is given but it should be I_a1 = 65 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.8, Page number 197-198" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "I_Lnl = 5.0 #Current drawn at no-load(A)\n", + "V_t = 230.0 #Supply voltage at no-load(V)\n", + "R_a = 0.25 #Armature circuit resistance(ohm)\n", + "R_sh = 115 #Field circuit resistance(ohm)\n", + "I_L = 40.0 #Current under load condition(A)\n", + "\n", + "#Calculation\n", + "#Under No-load condition\n", + "P_in1 = V_t*I_Lnl #Input power(W)\n", + "I_sh = V_t/R_sh #Shunt field current(A)\n", + "I_a1 = I_Lnl-I_sh #Armature current(A)\n", + "P_acu1 = I_a1**2*R_a #Armature copper loss(W)\n", + "P_shcu = I_sh**2*R_sh #Shunt field copper loss(W)\n", + "P_iron_friction = P_in1-(P_acu1+P_shcu) #Iron and friction losses(W)\n", + "#Under load condition\n", + "I_a2 = I_L-I_sh #Armature current(A)\n", + "P_acu2 = I_a2**2*R_a #Armature copper loss(W)\n", + "P_loss = P_iron_friction+P_shcu+P_acu2 #Total losses(W)\n", + "P_in2 = V_t*I_L #Input power(W)\n", + "P_0 = P_in2-P_loss #Output power(W)\n", + "n = (P_0/P_in2)*100 #Efficiency(percent)\n", + "\n", + "#Result\n", + "print('Iron and friction losses , P_iron_friction = %.2f W' %P_iron_friction)\n", + "print('Efficiency , \u03b7 = %.f percent' %n)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Iron and friction losses , P_iron_friction = 687.75 W\n", + "Efficiency , \u03b7 = 84 percent\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.9, Page number 198-199" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "I_L = 80.0 #Current drawn(A)\n", + "V_t = 220.0 #Supply voltage(V)\n", + "N = 800.0 #Speed(rpm)\n", + "R_a = 0.1 #Armature resistance(ohm)\n", + "R_sh = 50.0 #Shunt field resistance(ohm)\n", + "P_if = 1600.0 #Iron and friction losses(W)\n", + "\n", + "#Calculation\n", + "I_sh = V_t/R_sh #Shunt field current(A)\n", + "I_a = I_L-I_sh #Armature current(A)\n", + "E_b = V_t-I_a*R_a #Back emf(V)\n", + "#For case(i)\n", + "P_in = V_t*I_L #Input power(W)\n", + "P_md = E_b*I_a #Mechanical power developed in the armature(W)\n", + "P_cu = P_in-P_md #Copper loss(W)\n", + "#For case(ii)\n", + "T_a = 9.55*E_b*I_a/N #Armature torque(N-m)\n", + "#For case(iii)\n", + "P_0 = P_md-P_if #Output power(W)\n", + "T_sh = 9.55*P_0/N #Shaft torque(N-m)\n", + "#For case(iv)\n", + "n = (P_0/P_in)*100 #Efficiency(percent)\n", + "\n", + "#Result\n", + "print('(i) Copper losses , P_cu = %.2f W' %P_cu)\n", + "print('(ii) Armature torque , T_a = %.2f N-m' %T_a)\n", + "print('(iii) Shaft torque , T_sh = %.2f N-m' %T_sh)\n", + "print('(iv) Efficiency , \u03b7 = %.f percent' %n)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Copper losses , P_cu = 1539.54 W\n", + "(ii) Armature torque , T_a = 191.72 N-m\n", + "(iii) Shaft torque , T_sh = 172.62 N-m\n", + "(iv) Efficiency , \u03b7 = 82 percent\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_6.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_6.ipynb new file mode 100755 index 00000000..84ed6f6b --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_6.ipynb @@ -0,0 +1,311 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 6: CONTROL AND STARTING OF A DC MOTOR" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.1, Page number 212" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_t = 220.0 #Supply voltage(V)\n", + "I_a1 = 10.0 #Armature current(A)\n", + "N_1 = 900.0 #Speed(rpm)\n", + "R_a = 1.0 #Armature resistance(ohm)\n", + "N_2 = 500.0 #Reduced speed(rpm)\n", + "\n", + "#Calculation\n", + "E_b1 = V_t-I_a1*R_a #Initial back emf(V)\n", + "R = E_b1/I_a1*(1-(N_2/N_1)) #Value of additional resistance(ohm)\n", + "\n", + "#Result\n", + "print('Value of additional resistance , R = %.1f ohm' %R)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of additional resistance , R = 9.3 ohm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.2, Page number 212-213" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_t = 230.0 #Supply voltage(V)\n", + "I_a1 = 15.0 #Armature current(A)\n", + "N_1 = 650.0 #Speed(rpm)\n", + "R_a = 0.4 #Armature resistance(ohm)\n", + "R = 1.0 #Variable resistance in series with the armature(ohm)\n", + "\n", + "#Calculation \n", + "E_b1 = V_t-I_a1*R_a #Initial back emf(V)\n", + "#At full load torque\n", + "E_b2 = V_t-I_a1*(R+R_a) #Final back emf(V)\n", + "N_2 = N_1*(E_b2/E_b1) #Speed at full load torque(rpm)\n", + "\n", + "#At half load torque\n", + "I_a2hl = I_a1/2 #Armature current(A)\n", + "E_b2hl = V_t-I_a2hl*(R+R_a) #Back emf(V)\n", + "N_2hl = N_1*(E_b2hl/E_b1) #Speed at half load torque(rpm)\n", + "\n", + "#Result\n", + "print('Speed at full load torque , N_2 = %.1f rpm' %N_2)\n", + "print('Speed at half load torque , N_2 = %.1f rpm' %N_2hl)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed at full load torque , N_2 = 606.5 rpm\n", + "Speed at half load torque , N_2 = 636.9 rpm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.3, Page number 215-216" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_t = 230.0 #Supply voltage(V)\n", + "R_af = 0.2 #Total resistance of armature & field(ohm)\n", + "I_a1 = 10.0 #Armature current for certain load(A)\n", + "N = 1000.0 #Motor speed for certain load(rpm)\n", + "R_1 = 0 #Variable resistance for certain load(ohm)\n", + "I_a2 = 8.0 #Armature current for other load(A)\n", + "R_2 = 2.0 #Variable resistance for other load(ohm)\n", + "phi_1 = 1.0 #Assuming flux in certain load(Wb)\n", + "phi_2 = 0.8*phi_1 #Flux in other load(Wb)\n", + "\n", + "#Calculation\n", + "#For certain load\n", + "R_a1 = R_af+R_1 #New armature resistance(ohm)\n", + "E_b1 = V_t-I_a1*R_a1 #Back emf(V)\n", + "#For other load\n", + "R_a2 = R_af+R_2 #New armature resistance(ohm)\n", + "E_b2 = V_t-I_a2*R_a2 #Back emf(V)\n", + "N_2 = (E_b2/E_b1)*(phi_1/phi_2)*N #New speed(rpm) \n", + "\n", + "#Result\n", + "print('New speed , N_2 = %.1f rpm' %N_2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New speed , N_2 = 1164.5 rpm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.4, Page number 216-218" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "N = 1100.0 #Speed of dc series motor(rpm)\n", + "P = 4.0 #Number of poles\n", + "path = 4.0 #Number of parallel paths\n", + "I_a1 = 15.0 #Supply current to dc series motor(A)\n", + "V_t = 220.0 #Supply voltage(V)\n", + "R_a = 0.9 #Series armature resistance(ohm)\n", + "R_se = 0.6 #Series field resistance(ohm)\n", + "I_a2 = 25 #Supply current to dc series motor(A)\n", + "phi_1 = 1.0 #Assuming flux for 15 A case(Wb)\n", + "phi_2 = 0.8*phi_1 #Flux in 25 A case(Wb)\n", + "\n", + "#Calculation\n", + "#First case\n", + "R_se1 = R_se #Total series field resistance(ohm)\n", + "E_b1 = V_t-I_a1*(R_a+R_se1) #Back emf(V)\n", + "#Second case\n", + "R_se2 = R_se1/path #Total series field resistance(ohm)\n", + "E_b2 = V_t-I_a2*(R_a+R_se2) #Back emf(V)\n", + "N_2 = (E_b2/E_b1)*(phi_1/phi_2)*N #New speed(rpm) \n", + "\n", + "#Result\n", + "print('Speed for second case , N_2 = %.1f rpm = %.f rpm' %(N_2,N_2))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed for second case , N_2 = 1348.9 rpm = 1349 rpm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.5, Page number 233-234" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_t = 230.0 #Shunt motor supply voltage(V)\n", + "R_a = 0.4 #Armature resistance(ohm)\n", + "I_a = 30.0 #Armature current(A)\n", + "n = 3.0 #Number of steps\n", + "\n", + "#Calculation\n", + "R_1 = V_t/I_a #Maximum resistance(ohm)\n", + "k = (R_1/R_a)**(1.0/3) #Constant\n", + "R_2 = R_1/k #Resistance(ohm)\n", + "R_3 = R_2/k #Resistance(ohm)\n", + "R_4 = R_3/k #Resistance(ohm)\n", + "R_1step = R_1-R_2 #Resistance of the first step(ohm)\n", + "R_2step = R_2-R_3 #Resistance of the second step(ohm)\n", + "R_3step = R_3-R_4 #Resistance of the third step(ohm)\n", + "\n", + "#Result\n", + "print('Resistance of the first step , R_1step = %.1f ohm' %R_1step)\n", + "print('Resistance of the second step , R_2step = %.1f ohm' %R_2step)\n", + "print('Resistance of the third step , R_3step = %.2f ohm' %R_3step)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Resistance of the first step , R_1step = 4.8 ohm\n", + "Resistance of the second step , R_2step = 1.8 ohm\n", + "Resistance of the third step , R_3step = 0.67 ohm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.6, Page number 234-236" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_t = 220.0 #Shunt motor supply voltage(V)\n", + "P_0 = 3550.0 #Output power(W) \n", + "n = 0.85 #Efficiency\n", + "\n", + "#Calculation\n", + "P_in = P_0/n #Input power(W)\n", + "P_tloss = P_in-P_0 #Total loss(W)\n", + "I_a = P_in/V_t #Armature current(A)\n", + "P_cu = P_tloss/2 #Copper loss(W)\n", + "R_a = P_cu/I_a**2 #Armature resistance(ohm)\n", + "I_1 = 2*I_a #Maximum starting current(A)\n", + "R_1 = V_t/I_1 #Maximum resistance(ohm)\n", + "k = (R_1/R_a)**(1.0/4) #Constant\n", + "R_2 = R_1/k #Resistance(ohm)\n", + "R_3 = R_2/k #Resistance(ohm)\n", + "R_4 = R_3/k #Resistance(ohm)\n", + "R_5 = R_4/k #Resistance(ohm)\n", + "R_1step = R_1-R_2 #Resistance of the first step(ohm)\n", + "R_2step = R_2-R_3 #Resistance of the second step(ohm)\n", + "R_3step = R_3-R_4 #Resistance of the third step(ohm)\n", + "R_4step = R_4-R_5 #Resistance of the fourth step(ohm)\n", + "\n", + "#Result\n", + "print('Resistance of the first step , R_1step = %.1f ohm' %R_1step)\n", + "print('Resistance of the second step , R_2step = %.2f ohm' %R_2step)\n", + "print('Resistance of the third step , R_3step = %.2f ohm' %R_3step)\n", + "print('Resistance of the fourth step , R_4step = %.2f ohm' %R_4step)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Resistance of the first step , R_1step = 2.2 ohm\n", + "Resistance of the second step , R_2step = 1.36 ohm\n", + "Resistance of the third step , R_3step = 0.85 ohm\n", + "Resistance of the fourth step , R_4step = 0.53 ohm\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_7.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_7.ipynb new file mode 100755 index 00000000..167a7464 --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_7.ipynb @@ -0,0 +1,400 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 7: THREE-PHASE INDUCTION MOTOR" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.1, Page number 246-247" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V = 230.0 #Supply voltage(V)\n", + "P = 4.0 #Number of poles\n", + "f = 50.0 #Frequency(Hz)\n", + "N_l = 1445.0 #Full load speed(rpm)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "N_s = 120*f/P #Synchronous speed(rpm)\n", + "#For case(ii)\n", + "s = (N_s-N_l)/N_s #Slip\n", + "#For case(iii)\n", + "f_r = s*f #Rotor frequency(Hz)\n", + "\n", + "#Result\n", + "print('(i) Synchronous speed , N_s = %.f rpm' %N_s)\n", + "print('(ii) Slip , s = %.4f ' %s)\n", + "print('(iii) Rotor frequency , f_r = %.1f Hz' %f_r)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Synchronous speed , N_s = 1500 rpm\n", + "(ii) Slip , s = 0.0367 \n", + "(iii) Rotor frequency , f_r = 1.8 Hz\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.2, Page number 247-248" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "E_BR = 120.0 #Voltage under blocked condition(V)\n", + "P = 4.0 #Number of poles\n", + "f = 50.0 #Frequency(Hz)\n", + "N_l = 1450.0 #Speed(rpm)\n", + "\n", + "#Calculation\n", + "N_s = 120*f/P #Synchronous speed(rpm)\n", + "s = (N_s-N_l)/N_s #Slip\n", + "f_r = s*f #Rotor frequency(Hz)\n", + "E_r = s*E_BR #Rotor voltage(V)\n", + "\n", + "#Result\n", + "print('Synchronous speed , N_s = %.f rpm' %N_s)\n", + "print('Rotor frequency , f_r = %.2f Hz' %f_r)\n", + "print('Rotor voltage , E_r = %.2f V' %E_r)\n", + "print('\\nNOTE : Changes in answer is due to precision i.e more number of decimal places')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronous speed , N_s = 1500 rpm\n", + "Rotor frequency , f_r = 1.67 Hz\n", + "Rotor voltage , E_r = 4.00 V\n", + "\n", + "NOTE : Changes in answer is due to precision i.e more number of decimal places\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.3, Page number 250" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V_0 = 230.0 #Supply voltage(V)\n", + "P = 4.0 #Number of poles\n", + "T_0 = 230.0 #Original torque(N-m)\n", + "V_s = 150.0 #Stator voltage(V)\n", + "I_0 = 560.0 #Starting current(A)\n", + "\n", + "#Calculation\n", + "T_st = (V_s/V_0)**2*T_0 #Starting torque(N-m)\n", + "I_st = I_0*(V_s/V_0) #Starting current(A)\n", + "\n", + "#Result\n", + "print('Starting torque , T_st = %.1f N-m' %T_st)\n", + "print('Starting current , I_st = %.1f A' %I_st)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Starting torque , T_st = 97.8 N-m\n", + "Starting current , I_st = 365.2 A\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.4, Page number 254" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "f = 50.0 #Frequency(Hz)\n", + "P = 8.0 #Number of poles\n", + "a = 0.03 #Full load slip\n", + "R_2 = 0.01 #Rotor resistance per phase(ohm)\n", + "X_2 = 0.1 #Standstill reactance per phase(ohm)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "N_s = 120*f/P #Synchronous speed(rpm)\n", + "s = R_2/X_2 #Slip at maximum torque\n", + "N_l = (1-s)*N_s #Rotor speed at maximum torque(rpm)\n", + "#For case(ii)\n", + "T = (s**2+a**2)/(2*a*s) #Ratio of maximum torque to full load torque\n", + "\n", + "#Result\n", + "print('(i) Speed at which maximum torque occurs , N_l = %.f rpm' %N_l)\n", + "print('(ii) Ratio of the maximum torque to full load torque , T_max/T_f = %.2f ' %T)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Speed at which maximum torque occurs , N_l = 675 rpm\n", + "(ii) Ratio of the maximum torque to full load torque , T_max/T_f = 1.82 \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.5, Page number 260" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V = 440.0 #Supply voltage(V)\n", + "P = 4.0 #Number of poles\n", + "P_ag = 1500.0 #Rotor input(W)\n", + "P_rcu = 250.0 #Copper loss(W)\n", + "f = 50.0 #Frequency(Hz)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "s = P_rcu/P_ag #Slip\n", + "#For case(ii)\n", + "N_s = 120*f/P #Synchronous speed(rpm)\n", + "#For case(iii)\n", + "N_l = (1-s)*N_s #Shaft speed(rpm)\n", + "#For case(iv)\n", + "P_mech = (1-s)*P_ag #Mechanical power developed(W)\n", + "\n", + "#Result\n", + "print('(i) Slip , s = %.2f' %s)\n", + "print('(ii) Synchronous speed , N_s = %.f rpm' %N_s)\n", + "print('(iii) Shaft speed , N_l = %.f rpm' %N_l)\n", + "print('(iv) Mechanical power developed , P_mech = %.f W' %P_mech)\n", + "print('\\nNOTE : Changes in answer is due to precision i.e more number of decimal places')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Slip , s = 0.17\n", + "(ii) Synchronous speed , N_s = 1500 rpm\n", + "(iii) Shaft speed , N_l = 1250 rpm\n", + "(iv) Mechanical power developed , P_mech = 1250 W\n", + "\n", + "NOTE : Changes in answer is due to precision i.e more number of decimal places\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.6, Page number 264" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "V_1 = 150.0 #Supply voltage(V)\n", + "P = 4.0 #Number of poles\n", + "f = 50.0 #Frequency(Hz)\n", + "Z_1 = complex(0.12,0.16) #Per phase standstill stator impedance(ohm)\n", + "Z_2 = complex(0.22,0.28) #Per phase standstill rotor impedance(ohm)\n", + "\n", + "#Calculation\n", + "Z_eq = Z_1+Z_2 #Equivalent impedance(ohm)\n", + "R_eq = Z_eq.real\n", + "P_mech = 3*V_1**2/(2*(R_eq+abs(Z_eq)))*10**-3 #Maximum mechanical power developed(kW)\n", + "R_2 = Z_2.real\n", + "s_mp = R_2/(abs(Z_eq)+R_2) #Slip\n", + "W_s = 2*math.pi*2*f/P #Synchronous speed(rad/s)\n", + "W = (1-s_mp)*W_s #Speed of rotor(rad/s)\n", + "T_mxm = P_mech*1000/W #Maximum torque(N-m) \n", + "\n", + "#Result\n", + "print('Maximum mechanical power , P_mech = %.2f kW' %P_mech)\n", + "print('Maximum torque , T_mxm = %.2f N-m' %T_mxm)\n", + "print('Slip , s_mp = %.2f ' %s_mp)\n", + "print('\\nNOTE : Changes in answer is due to precision i.e more number of decimal places')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum mechanical power , P_mech = 37.66 kW\n", + "Maximum torque , T_mxm = 334.65 N-m\n", + "Slip , s_mp = 0.28 \n", + "\n", + "NOTE : Changes in answer is due to precision i.e more number of decimal places\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.7, Page number 265-266" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V = 440.0 #Supply voltage(V)\n", + "P = 6.0 #Number of poles\n", + "f = 50.0 #Frequency(Hz)\n", + "P_a = 45000.0 #Input power(W)\n", + "N_l = 900.0 #Speed(rpm)\n", + "P_tloss = 2000.0 #Total stator losses(W)\n", + "P_fw = 1000.0 #Friction and windage losses(W)\n", + "\n", + "#Calculation\n", + "N_s = 120*f/P #Synchronous speed(rpm)\n", + "s = (N_s-N_l)/N_s #Slip\n", + "P_ag = (P_a-P_tloss) #Air gap power(W)\n", + "P_rcu = s*P_ag #Rotor copper loss(W)\n", + "P_mech = P_ag-P_rcu #Mechanical power(W)\n", + "P_0 = P_mech-(P_tloss+P_fw) #Output power(W)\n", + "n = (P_0/P_ag)*100 #Efficiency(percent)\n", + "\n", + "#Result\n", + "print('(i) Slip , s = %.1f ' %s)\n", + "print('(ii) Rotor copper loss , P_rcu = %.f W' %P_rcu)\n", + "print('(iii) Shaft or Output power , P_0 = %.f W' %P_0)\n", + "print('(iv) Efficiency , \u03b7 = %.f percent' %n)\n", + "print('\\nNOTE : ERROR : Friction & windage losses are 1 kW not 1.5 kW as given in textbook question')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Slip , s = 0.1 \n", + "(ii) Rotor copper loss , P_rcu = 4300 W\n", + "(iii) Shaft or Output power , P_0 = 35700 W\n", + "(iv) Efficiency , \u03b7 = 83 percent\n", + "\n", + "NOTE : ERROR : Friction & windage losses are 1 kW not 1.5 kW as given in textbook question\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.8, Page number 268-269" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "v_s = 120.0 #Train speed(km/h)\n", + "f = 50.0 #Stator frequency(Hz)\n", + "\n", + "#Calculation\n", + "v_s1 = v_s*1000/(60*60) #Train speed(m/s)\n", + "w = v_s1/(2*f) #Length of the pole-pitch(m)\n", + "\n", + "#Result\n", + "print('Length of the pole-pitch of linear induction motor , w = %.2f m' %w)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Length of the pole-pitch of linear induction motor , w = 0.33 m\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_8.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_8.ipynb new file mode 100755 index 00000000..ae1358cd --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_8.ipynb @@ -0,0 +1,337 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 8: STARTING, CONTROL AND TESTING OF AN INDUCTION MOTOR" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.1, Page number 273" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "T_st = '1.5*T_f' #Starting torque\n", + "s = 0.03 #Slip\n", + "\n", + "#Calculation\n", + "I_sc_I_f = (1.5/s)**0.5 #I_sc/I_f\n", + "\n", + "#Result\n", + "print('Short circuit current , I_sc = %.2f*I_f' %I_sc_I_f)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Short circuit current , I_sc = 7.07*I_f\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.2, Page number 274-275" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "T_ratio = 50.0/100 #Ratio of starting torque to full load torque T_st/T_f\n", + "s_f = 0.03 #Full load slip\n", + "I_ratio = 5.0 #Ratio of short circuit current to full load current I_sc/I_f\n", + "\n", + "#Calculation\n", + "x = (1/I_ratio)*(T_ratio/s_f)**0.5 #Percentage of taping\n", + "\n", + "#Result\n", + "print('Percentage tapings required on the autotransformer , x = %.3f ' %x)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Percentage tapings required on the autotransformer , x = 0.816 \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.3, Page number 277" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "T_ratio = 25.0/100 #Ratio of starting torque to full load torque T_st/T_f\n", + "I_ratio = 3.0*120/100 #Ratio of short circuit current to full load current I_sc/I_f\n", + "\n", + "#Calculation\n", + "s_f = T_ratio*3/I_ratio**2 #Full load slip\n", + "\n", + "#Result\n", + "print('Full load slip , s_f = %.2f ' %s_f)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full load slip , s_f = 0.06 \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.4, Page number 281-282" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Z_icr = complex(0.04,0.5) #Inner cage impedance per phase at standstill(ohm)\n", + "Z_ocr = complex(0.4,0.2) #Outer cage impedance per phase at standstill(ohm)\n", + "V = 120.0 #Per phase rotor induced voltage at standstill(V)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "Z_com = (Z_icr*Z_ocr)/(Z_icr+Z_ocr) #Combined impedance(ohm)\n", + "I_2 = V/abs(Z_com) #Rotor current per phase(A)\n", + "R_2 = Z_com.real #Combined rotor resistance(ohm)\n", + "T = I_2**2*R_2 #Torque at stand still condition(synchronous watts)\n", + "#For case(ii)\n", + "s = 0.06 #Slip\n", + "R_ocr = Z_ocr.real\n", + "X_ocr = Z_ocr.imag\n", + "R_icr = Z_icr.real\n", + "X_icr = Z_icr.imag\n", + "Z_com6 = complex(R_ocr/s,X_ocr)*complex(R_icr/s,X_icr)/complex(R_ocr/s+R_icr/s,X_ocr+X_icr) #Combined impedance(ohm)\n", + "I2_6 = V/abs(Z_com6) #Rotor current per phase(A)\n", + "R2_6 = Z_com6.real #Combined rotor resistance(ohm)\n", + "T_6 = I2_6**2*R2_6 #Torque at 6% slip(synhronous watts)\n", + "\n", + "#Result\n", + "print('(i) Torque at standstill condition , T = %.2f syn.watt' %T)\n", + "print('(ii) Torque at 6 percent slip , T_6 = %.2f syn.watt' %T_6)\n", + "print('\\nNOTE : Changes in answer is due to precision i.e more number of decimal places')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Torque at standstill condition , T = 31089.35 syn.watt\n", + "(ii) Torque at 6 percent slip , T_6 = 15982.06 syn.watt\n", + "\n", + "NOTE : Changes in answer is due to precision i.e more number of decimal places\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.5, Page number 285" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "V = 210.0 #Supply voltage(V)\n", + "f = 50.0 #Supply frequency(Hz)\n", + "P = 50.0 #Input power(W)\n", + "I_br = 2.5 #Line current(A)\n", + "V_L = 25.0 #Line voltage(V)\n", + "R_1 = 2.4 #DC resistance between any two terminal(ohm)\n", + "\n", + "#Calculation\n", + "V_br = V_L/3**0.5 #Phase voltage(V)\n", + "P_br = P/3 #Power per phase(W)\n", + "R_eq = P_br/I_br**2 #Equivalent resistance(ohm)\n", + "R_2 = R_eq-(R_1/2) #Per phase rotor resistance(ohm)\n", + "Z_eq = V_br/I_br #Equivalent impedance(ohm)\n", + "X_eq = (Z_eq**2-R_2**2)**0.5 #Equivalent reactance(ohm)\n", + "X_1 = 0.5*X_eq #For practical cases reactances(ohm)\n", + "\n", + "#Result\n", + "print('Equivalent resistance , R_eq = %.1f ohm' %R_eq)\n", + "print('Equivalent impedance , Z_eq = %.1f ohm' %Z_eq)\n", + "print('Equivalent reactance , X_eq = %.1f ohm' %X_eq)\n", + "print('Per phase rotor resistance , R_2 = %.1f ohm' %R_2)\n", + "print('Reactances for practical cases , X_1 = X_2 = %.1f ohm' %X_1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Equivalent resistance , R_eq = 2.7 ohm\n", + "Equivalent impedance , Z_eq = 5.8 ohm\n", + "Equivalent reactance , X_eq = 5.6 ohm\n", + "Per phase rotor resistance , R_2 = 1.5 ohm\n", + "Reactances for practical cases , X_1 = X_2 = 2.8 ohm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.6, Page number 287" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "V = 210.0 #Supply voltage(V)\n", + "f = 50.0 #Supply frequency(Hz)\n", + "P = 4.0 #Number of poles\n", + "P_0 = 400.0 #Input power(W)\n", + "I_0 = 1.2 #Line current(A)\n", + "V_0 = 210.0 #Line voltage(V)\n", + "P_fw = 150.0 #Total friction and windage losses(W)\n", + "R = 2.2 #Stator resistance between any two terminals(ohm)\n", + " \n", + "#Calculation\n", + "R_1 = R/2 #Per phase stator resistance(ohm)\n", + "P_scu = 3*I_0**2*R_1 #Stator copper loss(W)\n", + "P_core = P_0-P_fw-P_scu #Stator core loss(W)\n", + "R_0 = (V_0/3**0.5)**2/(P_core/3) #No-load resistance(ohm)\n", + "#Alternate approach\\n\",\n", + "phi_0 = math.acos(P_core/(3**0.5*V_0*I_0)) #Power factor angle(radians)\n", + "phi_0_deg = phi_0*180/math.pi #Power factor angle(degree)\n", + "R_01 = (V_0/3**0.5)/(I_0*math.cos(phi_0)) #No-load circuit resistance per phase(ohm)\n", + "X_0 = (V_0/3**0.5)/(I_0*math.sin(phi_0)) #Magnetizing reactance per phase(ohm)\n", + " \n", + "#Result\n", + "print('Stator core loss , P_core = %.1f W' %P_core)\n", + "print('No-load circuit resistance per phase , R_0 = %.1f ohm' %R_01)\n", + "print('Magnetizing reactance per phase , X_0 = %.f ohm' %X_0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Stator core loss , P_core = 245.2 W\n", + "No-load circuit resistance per phase , R_0 = 179.8 ohm\n", + "Magnetizing reactance per phase , X_0 = 122 ohm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.7, Page number 290" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P_1 = 6.0 #Number of pole\n", + "P_2 = 4.0 #Number of pole\n", + "f = 50.0 #Supply frequency(Hz)\n", + "P = 60.0 #Power(kW)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "s = P_2/(P_1+P_2) #Combined slip\n", + "#For case(ii)\n", + "N_cs = 120*f/(P_1+P_2) #Combined synchronous speed(rpm)\n", + "#For case(iii)\n", + "P_0 = P*P_2/(P_1+P_2) #Output of 4-pole motor(kW)\n", + "\n", + "#Result\n", + "print('(i) Combined slip , s = %.1f ' %s)\n", + "print('(ii) Combined synchronous speed , N_cs = %.f rpm' %N_cs)\n", + "print('(iii) Output of the 4-pole motor , P_0 = %.f kW' %P_0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Combined slip , s = 0.4 \n", + "(ii) Combined synchronous speed , N_cs = 600 rpm\n", + "(iii) Output of the 4-pole motor , P_0 = 24 kW\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_9.ipynb b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_9.ipynb new file mode 100755 index 00000000..35fe3167 --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/CH_9.ipynb @@ -0,0 +1,625 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "CHAPTER 9: SYNCHRONOUS GENERATOR" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.1, Page number 295" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "N = 300.0 #Speed of water turbine(rpm)\n", + "f = 50.0 #Frequency of induced voltage(Hz)\n", + "\n", + "#Calculation\n", + "P = 120*f/N #Number of poles\n", + "\n", + "#Result\n", + "print('Number of poles of the generator , P = %.f poles' %P)\n", + "print('Alternatively , %.f pairs of north(N) and south(S) poles' %(P/2))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Number of poles of the generator , P = 20 poles\n", + "Alternatively , 10 pairs of north(N) and south(S) poles\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.2, Page number 299-300" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P = 8.0 #Number of poles\n", + "m = 3.0 #Number of phase \n", + "S = 144.0 #Number of slots\n", + "\n", + "#Calculation\n", + "T_p = S/P #Pole pitch(slots)\n", + "slots_1 = 180/T_p #Pole pitch per slot(degree)\n", + "gamma = 2*slots_1 #Short pitch angle(degree)\n", + "y = gamma*math.pi/180 #Short pitch angle(radian)\n", + "k_p = math.cos(y/2) #Pitch factor\n", + "\n", + "#Result\n", + "print('Pitch factor , k_p = %.2f ' %k_p)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Pitch factor , k_p = 0.98 \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.3, Page number 300-301" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P = 4.0 #Number of poles\n", + "m = 3.0 #Number of phase \n", + "S = 40.0 #Number of slots\n", + "s_1 = 1.0 #Coil span\n", + "s_2 = 9.0 #Coil span\n", + "\n", + "#Calculation\n", + "T_p = S/P #Pole pitch(slots)\n", + "T_c = s_2-s_1 #Coil pitch for coil spans 1 to 9(slots)\n", + "slots = 180/T_p #Pole pitch per slot(degree)\n", + "y = T_p-T_c #Short pitch angle(slots)\n", + "gamma = y*slots #Short pitch angle(degree)\n", + "y = gamma*math.pi/180 #Short pitch angle(radian)\n", + "k_p = math.cos(y/2) #Pitch factor\n", + "\n", + "#Result\n", + "print('Pitch factor , k_p = %.2f ' %k_p)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Pitch factor , k_p = 0.95 \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.4, Page number 302" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P = 4.0 #Number of poles\n", + "S = 48.0 #Number of slots\n", + "m = 3.0 #Number of phase \n", + "\n", + "#Calculation\n", + "T_p = S/P #Pole pitch(slots)\n", + "slot = 180/T_p #Pole pitch per slot(degree)\n", + "a = slot*math.pi/180 #Pole pitch per slot(radian)\n", + "n = S/(P*m) #Number of slots or coils per pole per phase\n", + "k_d = math.sin(n*a/2)/(n*math.sin(a/2)) #Distribution factor\n", + "\n", + "#Result\n", + "print('Distribution factor , k_d = %.2f ' %k_d)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Distribution factor , k_d = 0.96 \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.5, Page number 304-305" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P = 12.0 #Number of poles\n", + "S = 180.0 #Number of slots\n", + "phi_m = 0.05 #Flux per pole(Wb)\n", + "N = 600.0 #Speed of machine(rpm)\n", + "m = 3.0 #Number of phase\n", + "\n", + "#Calculation\n", + "T_p = S/P #Pole pitch(slots)\n", + "slot = 180/T_p #Slots per pole(degree)\n", + "n = S/(P*m) #Number of slots or coils per pole per phase\n", + "a = slot*math.pi/180 #Pole pitch per slot(radian)\n", + "k_d = math.sin(n*a/2)/(n*math.sin(a/2)) #Distribution factor\n", + "k_p = 1.0 #Pitch factor\n", + "Z = (180/m)*slot #Number of conductors per phase\n", + "T = Z/2 #Number of turns per phase\n", + "f = P*N/120 #Frequency(Hz)\n", + "E = 4.44*k_p*k_d*f*phi_m*T #Induced voltage(V)\n", + "E_L = 3**0.5*E #Line voltage(V)\n", + "\n", + "#Result\n", + "print('Line voltage , E_L = %.1f V' %E_L)\n", + "print('\\nNOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line voltage , E_L = 7945.7 V\n", + "\n", + "NOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.6, Page number 305-307" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P = 4.0 #Number of poles\n", + "m = 3.0 #Number of phase \n", + "f = 50.0 #Frequency(Hz)\n", + "phi_m = 0.05 #Flux per pole(Wb)\n", + "n = 6.0 #Number of slots per pole per phase\n", + "cond = 5.0 #Conductors per layer\n", + "no_layer = 2.0 #Number of layer winding\n", + "\n", + "#Calculation\n", + "T_p = n*m #Slots per pole\n", + "slot = 180/T_p #Slots per pole(degree)\n", + "a = slot*math.pi/180 #Pole pitch per slot(radian)\n", + "T_c = (5.0/6)*T_p #Coil pitch is 5/6 of full pitch\n", + "gamma = T_p-T_c #Short pitch angle(slots)\n", + "y_angle = gamma*slot #Short pitch(angle)\n", + "y = y_angle*math.pi/180 #Short pitch(radians)\n", + "k_p = math.cos(y/2) #Pitch factor\n", + "k_d = math.sin(n*a/2)/(n*math.sin(a/2)) #Distribution factor\n", + "T = 1.0/2*n*P*cond*no_layer #Number of turns in any phase\n", + "E = 4.44*k_p*k_d*f*phi_m*T #Voltage per phase(V)\n", + "\n", + "#Result\n", + "print('Voltage per phase , E = %.2f V' %E)\n", + "print('\\nNOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage per phase , E = 1230.19 V\n", + "\n", + "NOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.7, Page number 307-308" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P = 10.0 #Number of poles\n", + "m = 3.0 #Number of phase \n", + "f = 50.0 #Frequency(Hz)\n", + "n = 3.0 #Number of slots per pole per phase\n", + "phi_m1 = 0.05 #Fundamental component of flux(Wb)\n", + "phi_m3 = 0.006 #Third harmonic component of flux(Wb)\n", + "T_c = 150.0 #Coil span(degree)\n", + "cond = 5.0 #Conductors per layer\n", + "no_layer = 2.0 #Number of layer winding\n", + "\n", + "#Calculation\n", + "T_p = n*m #Slots per pole\n", + "slot = 180/T_p #Slots per pole(degree)\n", + "a = slot*math.pi/180 #Pole pitch per slot(radian)\n", + "gamma = 180-T_c #Short pitch angle(degree)\n", + "y = gamma*math.pi/180 #Short pitch angle(radian)\n", + "T = 1.0/2*P*n*cond*no_layer #Number of turns\n", + "k_p1 = math.cos(y/2) #Fundamental pitch factor\n", + "k_d1 = math.sin(n*a/2)/(n*math.sin(a/2)) #Fundamental distribution factor\n", + "E_1 = 4.44*k_p1*k_d1*f*phi_m1*T #Fundamental emf per phase(V)\n", + "k_p3 = math.cos(3*y/2) #Third harmonic pitch factor\n", + "k_d3 = math.sin(3*n*a/2)/(n*math.sin(3*a/2)) #Third harmonic distribution factor\n", + "E_3 = 4.44*k_p3*k_d3*f*phi_m3*T #Voltage(V)\n", + "E = (E_1**2+E_3**2)**0.5 #Induced voltage per phase(V)\n", + "\n", + "#Result\n", + "print('rms value of induced voltage per phase , E = %.1f V' %E)\n", + "print('\\nNOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "rms value of induced voltage per phase , E = 1546.5 V\n", + "\n", + "NOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.8, Page number 312" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "kVA = 50.0 #Ratings(kVA)\n", + "V_t = 220.0 #Voltage(V)\n", + "R_a = 0.011 #Effective resistance(ohm)\n", + "X_s = 0.09 #Synchronous reactance(ohm)\n", + "pf = 0.85 #Lagging power factor\n", + "\n", + "#Calculation\n", + "phi = math.acos(pf) #Power factor angle(radians)\n", + "I_a = kVA*10**3/V_t #Armature current(A)\n", + "E_f = ((V_t*pf+I_a*R_a)**2+(V_t*math.sin(phi)+I_a*X_s)**2)**0.5 #Induced voltage per phase(V)\n", + "VR = ((E_f-V_t)/V_t)*100 #Voltage regulation(percent)\n", + "\n", + "#Result\n", + "print('No-load induced voltage per phase , E_f = %.1f V' %E_f)\n", + "print('Voltage regulation , VR = %.1f percent' %VR)\n", + "print('\\nNOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "No-load induced voltage per phase , E_f = 233.5 V\n", + "Voltage regulation , VR = 6.1 percent\n", + "\n", + "NOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.9, Page number 314" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "kVA = 200.0 #Rating(kVA)\n", + "V_t = 33.0*10**3 #Voltage(V)\n", + "R_a = 0.54 #Armature resistance(ohm)\n", + "V_L = 415.0 #Voltage between lines for SC test(V)\n", + "I_sh = 25.0 #Short circuit current(A)\n", + "pf = 0.9 #Lagging power factor\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "V_P = V_L/3**0.5 #Phase voltage during short circuit test(V)\n", + "Z_s = V_P/I_sh #Synchronous impedance(ohm)\n", + "#For case(ii)\n", + "X_s = (Z_s**2-R_a**2)**0.5 #Synchronous reactance(ohm)\n", + "#For case(iii)\n", + "I_a = kVA*1000/(3**0.5*V_t) #Full load current(A)\n", + "V_ta = V_t/3**0.5 #Voltage per phase of alternator(V)\n", + "phi = math.acos(pf) #Power factor angle(radians)\n", + "E_f = ((V_ta*pf+I_a*R_a)**2+(V_ta*math.sin(phi)+I_a*X_s)**2)**0.5 #No-load voltage per phase(V) \n", + "VR = ((E_f-V_ta)/V_ta)*100 #Voltage regulation\n", + "\n", + "#Result\n", + "print('(i) Synchronous impedance , Z_s = %.1f ohm' %Z_s)\n", + "print('(ii) Synchronous reactance , X_s = %.2f ohm' %X_s)\n", + "print('(iii) Voltage regulation , VR = %.2f percent' %VR)\n", + "print('\\nNOTE : ERROR : In textbook calculation , R_a is taken instead of X_s in calculation of E_f')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Synchronous impedance , Z_s = 9.6 ohm\n", + "(ii) Synchronous reactance , X_s = 9.57 ohm\n", + "(iii) Voltage regulation , VR = 0.09 percent\n", + "\n", + "NOTE : ERROR : In textbook calculation , R_a is taken instead of X_s in calculation of E_f\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.10, Page number 317" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "MVA = 30.0 #Rating(MVA)\n", + "V = 20.0 #Supply voltage(kV)\n", + "N = 1800.0 #Speed(rpm)\n", + "V_t = 15.0 #Voltage per phase(kV)\n", + "E_f = 10.0 #Per phase terminal voltage(kV)\n", + "delta = 40.0 #Power angle(degree)\n", + "X_s = 6.0 #Per phase synchronous reactance(ohm)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "d = delta*math.pi/180 #Power angle(radians)\n", + "P = 3*V_t*E_f*math.sin(d)/X_s #3-phase power delivered to the load(MW)\n", + "#For case(ii)\n", + "P_max = 3*V_t*E_f/X_s #Three phase maximum power(MW)\n", + "\n", + "#Result\n", + "print('(i) Three-phase real power delivered to the load , P = %.2f MW' %P)\n", + "print('(ii) Three-phase maximum power , P_max = %.f MW' %P_max)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Three-phase real power delivered to the load , P = 48.21 MW\n", + "(ii) Three-phase maximum power , P_max = 75 MW\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.11, Page number 321-322" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "kVA = 25.0 #Rating(kVA)\n", + "V = 440.0 #Suppy voltage(V)\n", + "f = 50.0 #Supply frequency(Hz)\n", + "pf = 0.8 #Lagging power factor\n", + "R_a = 0.3 #Resistance of machine per phase(ohm)\n", + "X_d = 5.0 #Reactance of machine per phase(ohm)\n", + "X_q = 3.0 #Reactance of machine per phase(ohm)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "phi = math.acos(pf) #Power factor angle(radians)\n", + "phi_deg = phi*180/math.pi #Power factor angle(degree)\n", + "V_t = V/3**0.5 #Terminal voltage per phase(V)\n", + "I_a = kVA*10**3/(3**0.5*V) #Armature current(A)\n", + "tan_d = (I_a*X_q*pf/(V_t+I_a*X_q*math.sin(phi)))\n", + "d = math.atan(tan_d) #Torque angle(radians)\n", + "d_angle = d*180/math.pi #Torque angle(degree)\n", + "#For case(ii)\n", + "I_d = I_a*math.sin(d+phi) #Direct axis component of the current(A)\n", + "E_f = V_t*math.cos(d)+I_d*X_d #Induced voltage per phase(V)\n", + "#For case(iii)\n", + "VR = ((E_f-V_t)/V_t)*100 #Voltage regulation(percent)\n", + "\n", + "#Result\n", + "print('(i) Torque angle , \u03b4 = %.2f\u00b0 ' %d_angle)\n", + "print('(ii) Induced voltage per phase , E_f = %.2f V' %E_f)\n", + "print('(iii) Voltage regulation , VR = %.2f percent' %VR)\n", + "print('\\nNOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Torque angle , \u03b4 = 14.12\u00b0 \n", + "(ii) Induced voltage per phase , E_f = 373.80 V\n", + "(iii) Voltage regulation , VR = 47.15 percent\n", + "\n", + "NOTE : Changes in obtained answer from that of textbook answer is due to precision i.e more number of decimal places\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.12, Page number 324-325" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration\n", + "E_1 = 220.0 #Induced voltage per phase by alternator 1(V)\n", + "E_2 = 220*cmath.exp(1j*5*math.pi/180) #Induced voltage per phase by alternator 2(V)\n", + "Z_1 = complex(0,3) #Impedance of alternator 1(ohm)\n", + "Z_2 = complex(0,4) #Impedance of alternator 2(ohm)\n", + "Z = 5.0 #Load(ohm)\n", + "\n", + "#Calculation\n", + "#For case(i)\n", + "I = (E_1*Z_2+E_2*Z_1)/(Z_1*Z_2+Z*(Z_1+Z_2)) #Load current(A)\n", + "#For case(ii)\n", + "V_t = I*Z #Terminal voltage(V)\n", + "#For case(iii)\n", + "I_a1 = ((E_1-E_2)*Z+E_1*Z_2)/(Z_1*Z_2+Z*(Z_1+Z_2)) #Armature current(A)\n", + "P_1 = abs(V_t*I_a1)*math.cos(cmath.phase(V_t)-cmath.phase(I_a1))*10**-3 #Power per phase delivered by the first alternator(W)\n", + "\n", + "#Result\n", + "print('(i) Load current , I = %.1f\u2220%.f\u00b0 A' %(abs(I),cmath.phase(I)*180/math.pi))\n", + "print('(ii) Terminal voltage , V_t = %.f\u2220%.f\u00b0 V' %(abs(V_t),cmath.phase(V_t)*180/math.pi))\n", + "print('(iii) Power per phase delivered by the first alternator , P_1 = %.1f kW' %P_1)\n", + "print('\\nNOTE : ERROR : In textbook case(iii) power calculation current I is taken instead of I_a1')" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Load current , I = 41.6\u2220-17\u00b0 A\n", + "(ii) Terminal voltage , V_t = 208\u2220-17\u00b0 V\n", + "(iii) Power per phase delivered by the first alternator , P_1 = 4.4 kW\n", + "\n", + "NOTE : ERROR : In textbook case(iii) power calculation current I is taken instead of I_a1\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/README.txt b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/README.txt new file mode 100755 index 00000000..eab345e3 --- /dev/null +++ b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/README.txt @@ -0,0 +1,10 @@ +Contributed By: KAVAN A B +Course: be +College/Institute/Organization: SRI JAYACHAMARAJENDRA COLLEGE OF ENGINEERING +Department/Designation: ELECTRICAL & ELECTRONICS +Book Title: Fundamentals of Electrical Machines +Author: M A Salam +Publisher: Narosa Publishing House, New Delhi - 110002 +Year of publication: 2009 +Isbn: 978-81-8487-163-0 +Edition: 2 \ No newline at end of file diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/1.png b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/1.png new file mode 100755 index 00000000..338e1e9b Binary files /dev/null and b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/1.png differ diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/2.png b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/2.png new file mode 100755 index 00000000..0f649c1a Binary files /dev/null and b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/2.png differ diff --git a/Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/3.png b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/3.png new file mode 100755 index 00000000..7ec6174d Binary files /dev/null and b/Fundamentals_of_Electrical_Machines_by_M_A_Salam/screenshots/3.png differ -- cgit