summaryrefslogtreecommitdiff
path: root/Fundamentals_of_Electrical_Machines
diff options
context:
space:
mode:
authornice2014-09-15 12:50:58 +0530
committernice2014-09-15 12:50:58 +0530
commit2792e8d6ecab454e3cb8fb1ea1f26f1613bc1e1c (patch)
tree680c46833c53f5ecbbceb773bec170a89ac94152 /Fundamentals_of_Electrical_Machines
parentf77c828fecc4db415b42d5b0e28a75dd135476d4 (diff)
downloadPython-Textbook-Companions-2792e8d6ecab454e3cb8fb1ea1f26f1613bc1e1c.tar.gz
Python-Textbook-Companions-2792e8d6ecab454e3cb8fb1ea1f26f1613bc1e1c.tar.bz2
Python-Textbook-Companions-2792e8d6ecab454e3cb8fb1ea1f26f1613bc1e1c.zip
added books
Diffstat (limited to 'Fundamentals_of_Electrical_Machines')
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_1.ipynb731
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_10.ipynb222
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_11.ipynb354
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_2.ipynb623
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_3.ipynb883
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_4.ipynb499
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_5.ipynb435
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_6.ipynb311
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_7.ipynb400
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_8.ipynb337
-rwxr-xr-xFundamentals_of_Electrical_Machines/CH_9.ipynb625
-rwxr-xr-xFundamentals_of_Electrical_Machines/README.txt10
-rwxr-xr-xFundamentals_of_Electrical_Machines/screenshots/1.pngbin0 -> 35222 bytes
-rwxr-xr-xFundamentals_of_Electrical_Machines/screenshots/2.pngbin0 -> 34615 bytes
-rwxr-xr-xFundamentals_of_Electrical_Machines/screenshots/3.pngbin0 -> 34828 bytes
15 files changed, 5430 insertions, 0 deletions
diff --git a/Fundamentals_of_Electrical_Machines/CH_1.ipynb b/Fundamentals_of_Electrical_Machines/CH_1.ipynb
new file mode 100755
index 00000000..801b1ed1
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_10.ipynb b/Fundamentals_of_Electrical_Machines/CH_10.ipynb
new file mode 100755
index 00000000..b3532e76
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_11.ipynb b/Fundamentals_of_Electrical_Machines/CH_11.ipynb
new file mode 100755
index 00000000..3c86183e
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_2.ipynb b/Fundamentals_of_Electrical_Machines/CH_2.ipynb
new file mode 100755
index 00000000..4a1c83c7
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_3.ipynb b/Fundamentals_of_Electrical_Machines/CH_3.ipynb
new file mode 100755
index 00000000..68c7ac6d
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_4.ipynb b/Fundamentals_of_Electrical_Machines/CH_4.ipynb
new file mode 100755
index 00000000..76dec5aa
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_5.ipynb b/Fundamentals_of_Electrical_Machines/CH_5.ipynb
new file mode 100755
index 00000000..27fbc256
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_6.ipynb b/Fundamentals_of_Electrical_Machines/CH_6.ipynb
new file mode 100755
index 00000000..84ed6f6b
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_7.ipynb b/Fundamentals_of_Electrical_Machines/CH_7.ipynb
new file mode 100755
index 00000000..167a7464
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_8.ipynb b/Fundamentals_of_Electrical_Machines/CH_8.ipynb
new file mode 100755
index 00000000..ae1358cd
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/CH_9.ipynb b/Fundamentals_of_Electrical_Machines/CH_9.ipynb
new file mode 100755
index 00000000..35fe3167
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/README.txt b/Fundamentals_of_Electrical_Machines/README.txt
new file mode 100755
index 00000000..eab345e3
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/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/screenshots/1.png b/Fundamentals_of_Electrical_Machines/screenshots/1.png
new file mode 100755
index 00000000..338e1e9b
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/screenshots/1.png
Binary files differ
diff --git a/Fundamentals_of_Electrical_Machines/screenshots/2.png b/Fundamentals_of_Electrical_Machines/screenshots/2.png
new file mode 100755
index 00000000..0f649c1a
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/screenshots/2.png
Binary files differ
diff --git a/Fundamentals_of_Electrical_Machines/screenshots/3.png b/Fundamentals_of_Electrical_Machines/screenshots/3.png
new file mode 100755
index 00000000..7ec6174d
--- /dev/null
+++ b/Fundamentals_of_Electrical_Machines/screenshots/3.png
Binary files differ
generated by cgit (git 2.34.1) at 2024-12-19 14:55:43 +0000