diff options
Diffstat (limited to 'DC_Machines_and_Synchronous_Machines')
17 files changed, 12429 insertions, 0 deletions
diff --git a/DC_Machines_and_Synchronous_Machines/README.txt b/DC_Machines_and_Synchronous_Machines/README.txt new file mode 100755 index 00000000..9c84b56e --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/README.txt @@ -0,0 +1,10 @@ +Contributed By: Hiren Shah +Course: mca +College/Institute/Organization: Financial Technology +Department/Designation: Developer +Book Title: DC Machines and Synchronous Machines +Author: U. A. Bakshi and M. V. Bakshi +Publisher: Technical Publications, Pune +Year of publication: 2008 +Isbn: 9788184314830 +Edition: 1
\ No newline at end of file diff --git a/DC_Machines_and_Synchronous_Machines/ch1.ipynb b/DC_Machines_and_Synchronous_Machines/ch1.ipynb new file mode 100755 index 00000000..04ab6c30 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/ch1.ipynb @@ -0,0 +1,1633 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:28530af987ec737018da049988fa2fb2a82d79acc8dd496873e17355c1e77828" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 1 : D.C. Generators" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.1 page no : 17" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "p = 4.\n", + "Z = 440.\n", + "theta = 0.07 # Wb\n", + "N = 900. # rpm\n", + "\n", + "# calculations and results\n", + "E = theta*N*Z/60.\n", + "print \"For lap wound : E = %.f V\"%E\n", + "\n", + "E = theta*N*Z*4/120.\n", + "print \"For wave wound : E = %.f V\"%E\n", + "\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For lap wound : E = 462 V\n", + "For wave wound : E = 924 V\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "\n", + "Example 1.2 page no : 18" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 4.\n", + "phi = 21.*10**-3 \t\t\t#flux produced by each pole in webers\n", + "N = 1120. \t\t\t#Speed of armature in r.p.m\n", + "Coils = 42.\n", + "turns_per_coil = 8.\n", + "Turns = Coils * turns_per_coil\n", + "Z = 2*Turns \t\t\t#Number of armature conductors\n", + "\n", + "# Calculations and Results\n", + "#Part(i)\n", + "A1 = Pole \t\t\t#no of parallel paths for lap winding\n", + "E1 = phi*N*Z*Pole/(60*A1)\n", + "print 'i) e.m.f generated is %.3f V'%(E1)\n", + "\n", + "#Part(ii)\n", + "A2 = 2 \t\t\t#wave winding\n", + "E2 = E1 \t\t\t#as mentioned in the question\n", + "N2 = E2/(phi*Z*Pole/(60*A2)) \t\t\t#E = phi*N*Z*Pole/(60*A)\n", + "print 'ii) For wave-wound armature,above calculated e.m.f is generated at %.0f r.p.m'%(N2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i) e.m.f generated is 263.424 V\n", + "ii) For wave-wound armature,above calculated e.m.f is generated at 560 r.p.m\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.3 page no: 27" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 4.\n", + "coils = 12.\n", + "commutator_segments = coils\n", + "coil_sides = coils*2\n", + "Z = coil_sides \t\t\t#No of conductors\n", + "pole_pitch = Z/Pole\n", + "\n", + "# Calculations and Results\n", + "#for Simplex lap winding\n", + "y_f = pole_pitch-1\n", + "y_b = pole_pitch+1\n", + "\n", + "y_c = 1 \t\t\t#Note that it's positive and it's progressive type of Simplex lap winding\n", + "\n", + "\n", + "print 'WINDING TABLE: 1<- 8-> 3<- 10-> 5<- 12-> 7<- 14-> 9<- 16-> 11<- 18->13<- 20-> 15<- 22-> 17<- 24->19<- 2-> 21<- 4-> 23<- 6-> 1 '\n", + "print 'Note that <- indicates back connection with y_back = %.0f and -> indicates front connection with y_front = %.0f'%(y_b,y_f)\n", + "print 'Another form of winding table:'\n", + "print ' BACK CONNECTIONS FRONT CONNECTIONS'\n", + "\n", + "print ' 1 to 1+7 = 8 -> 8 to 8-5 = 3'\n", + "print ' 3 to 3+7 = 10 -> 10 to 10-5 = 5'\n", + "print ' 5 to 5+7 = 12 -> 12 to 12-5 = 7'\n", + "print ' 7 to 7+7 = 14 -> 14 to 14-5 = 9'\n", + "print ' 9 to 9+7 = 16 -> 16 to 16-5 = 11'\n", + "print ' 11 to 11+7 = 18 -> 18 to 18-5 = 13'\n", + "print ' 13 to 13+7 = 20 -> 20 to 20-5 = 15'\n", + "print ' 15 to 15+7 = 22 -> 22 to 22-5 = 17'\n", + "print ' 17 to 17+7 = 24 -> 24 to 24-5 = 19'\n", + "print ' 19 to 19+7 = 26 = 26-24 = 2 -> 2 to 26-5 = 21'\n", + "print ' 21 to 21+7 = 28 = 28-24 = 4 -> 4 to 28-5 = 23'\n", + "print ' 23 to 23+7 = 30 = 30-24 = 6 -> 6 to 30-5 = 25 = 25-24 = 1'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "WINDING TABLE: 1<- 8-> 3<- 10-> 5<- 12-> 7<- 14-> 9<- 16-> 11<- 18->13<- 20-> 15<- 22-> 17<- 24->19<- 2-> 21<- 4-> 23<- 6-> 1 \n", + "Note that <- indicates back connection with y_back = 7 and -> indicates front connection with y_front = 5\n", + "Another form of winding table:\n", + " BACK CONNECTIONS FRONT CONNECTIONS\n", + " 1 to 1+7 = 8 -> 8 to 8-5 = 3\n", + " 3 to 3+7 = 10 -> 10 to 10-5 = 5\n", + " 5 to 5+7 = 12 -> 12 to 12-5 = 7\n", + " 7 to 7+7 = 14 -> 14 to 14-5 = 9\n", + " 9 to 9+7 = 16 -> 16 to 16-5 = 11\n", + " 11 to 11+7 = 18 -> 18 to 18-5 = 13\n", + " 13 to 13+7 = 20 -> 20 to 20-5 = 15\n", + " 15 to 15+7 = 22 -> 22 to 22-5 = 17\n", + " 17 to 17+7 = 24 -> 24 to 24-5 = 19\n", + " 19 to 19+7 = 26 = 26-24 = 2 -> 2 to 26-5 = 21\n", + " 21 to 21+7 = 28 = 28-24 = 4 -> 4 to 28-5 = 23\n", + " 23 to 23+7 = 30 = 30-24 = 6 -> 6 to 30-5 = 25 = 25-24 = 1\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.4 page no : 32" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 4.\n", + "Z = 18. \t\t\t#no of armature conductors\n", + "Y_A = (Z+2)/Pole \t\t\t#For progressive type wave winding,positive sign is used\n", + "Y_C = Y_A \t\t\t#For wave winding\n", + "\n", + "# Calculations\n", + "#Since Y_A = (y_b+y_f)/2, we let y_b = Y_f\n", + "y_b = Y_A/2 \t\t\t#say\n", + "y_f = y_b\n", + "\n", + "coils = Z/2\n", + "slots = coils\n", + "commutator_segments = coils\n", + "\n", + "print commutator_segments\n", + "print 'WINDING TABLE: 1<- 6-> 11<- 16-> 3<- 8->13<- 18-> 5<- 10-> 15<- 2-> 7<- 12-> 17<- 4-> 9<- 14->1 '\n", + "\n", + "print 'Another form of winding table:'\n", + "\n", + "print ' BACK CONNECTIONS FRONT CONNECTIONS'\n", + "\n", + "print ' 1 to 1+5 = 6 -> 6 to 6+5 = 11'\n", + "print ' 11 to 11+5 = 16 -> 16 to 16+5 = 21 -18 = 3'\n", + "print ' 3 to 3+5 = 8 -> 8 to 8+5 = 13'\n", + "print ' 13 to 13+5 = 18 -> 18 to 18+5 = 23 -18 = 5'\n", + "print ' 5 to 5+5 = 10 -> 10 to 10+5 = 15'\n", + "print ' 15 to 15+5 = 20 -18 = 2 -> 2 to 2+5 = 7'\n", + "print ' 7 to 7+5 = 12 -> 12 to 12+5 = 17'\n", + "print ' 17 to 17+5 = 22 -18 = 4 -> 4 to 4+5 = 9'\n", + "print ' 9 to 9+5 = 14 -> 14 to 14+5 = 19 -18 = 1'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "9.0\n", + "WINDING TABLE: 1<- 6-> 11<- 16-> 3<- 8->13<- 18-> 5<- 10-> 15<- 2-> 7<- 12-> 17<- 4-> 9<- 14->1 \n", + "Another form of winding table:\n", + " BACK CONNECTIONS FRONT CONNECTIONS\n", + " 1 to 1+5 = 6 -> 6 to 6+5 = 11\n", + " 11 to 11+5 = 16 -> 16 to 16+5 = 21 -18 = 3\n", + " 3 to 3+5 = 8 -> 8 to 8+5 = 13\n", + " 13 to 13+5 = 18 -> 18 to 18+5 = 23 -18 = 5\n", + " 5 to 5+5 = 10 -> 10 to 10+5 = 15\n", + " 15 to 15+5 = 20 -18 = 2 -> 2 to 2+5 = 7\n", + " 7 to 7+5 = 12 -> 12 to 12+5 = 17\n", + " 17 to 17+5 = 22 -18 = 4 -> 4 to 4+5 = 9\n", + " 9 to 9+5 = 14 -> 14 to 14+5 = 19 -18 = 1\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.5 page no : 42" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 4.\n", + "Z = 480. \t\t\t#No of armature conductors\n", + "I_a = 144.\n", + "I = I_a/2 \t\t\t#For wave wound\n", + "theta_m = 10. \t\t\t#lead angle in DEGREES\n", + "\n", + "# Calculations\n", + "amp_turns_PP_d = Z*I*theta_m/360 \t\t\t#demagnetising Ampere-turns per pole\n", + "amp_turns_PP_c = Z*I*(1/(2*Pole)-theta_m/360) \t\t\t#cross-magnetising Ampere-turns per pole\n", + "\n", + "# Results\n", + "print 'De-magnetising ampere-turns per pole is %.0f'%(amp_turns_PP_d)\n", + "print 'Cross-magnetising ampere-turns per pole is %.0f'%(amp_turns_PP_c)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "De-magnetising ampere-turns per pole is 960\n", + "Cross-magnetising ampere-turns per pole is 3360\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.6 page no : 46" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 10.\n", + "Z = 800. \t\t\t#No of armature conductors\n", + "A = Pole \t\t\t#For lap wound\n", + "ratio = 0.7 \t\t\t#ratio of pole arc to pole pitch\n", + "\n", + "# Calculations\n", + "#amp_turns_PP = ratio*(I_a*Z)/(2*A*P)\n", + "turns_PP = ratio*(Z)/(2*A*Pole) \t\t\t#turns per pole\n", + "conductors_PP = turns_PP*2 \t\t\t#multiplied with 2 because 2 conductors form 1 turn\n", + "\n", + "# Results\n", + "print 'Compensating conductors per pole = %.f'%(conductors_PP)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Compensating conductors per pole = 6\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.7 page no : 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "I_L = 150.\n", + "A = 4.\n", + "N = 1800. \t\t\t#in rpm\n", + "W_b = 1.2 \t\t\t#Brush width\n", + "W_m = 0 \t\t\t#width of mica insulation\n", + "L = 0.06*10**-3 \t\t\t#Inducmath.tance\n", + "segments = 64.\n", + "n_s = 1800./60 \t\t\t#in rps and not rpm\n", + "v = n_s*segments \t\t\t#peripheral speed in segments per second\n", + "\n", + "# Calculations and Results\n", + "T_c = (W_b-W_m)/v \t\t\t#Time of commutation\n", + "I = I_L/A \t\t\t#Current through a conductor\n", + "\n", + "#Part(i)\n", + "E_l = L*2*I/T_c\n", + "print 'i) Reactive voltage using Linear commutation is %.1f V'%(E_l)\n", + "\n", + "#Part(ii)\n", + "E_s = 1.11*L*2*I/T_c\n", + "print 'ii) Reactive voltage using Sinusoidal commutation is %.3f V'%(E_s)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i) Reactive voltage using Linear commutation is 7.2 V\n", + "ii) Reactive voltage using Sinusoidal commutation is 7.992 V\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.8 page no : 63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V_t = 250. \t\t\t#Terminal voltage\n", + "R_sh = 100. \t\t\t#resistance of shunt field winding\n", + "I_sh = V_t/R_sh \t\t\t#shunt current\n", + "R_a = 0.22 \t\t\t#Armature resistance\n", + "\n", + "# Calculations\n", + "P = 5*10**3 \t\t\t#Load power\n", + "I_L = P/V_t \t\t\t#Load current\n", + "I_a = I_L+I_sh \t\t\t#armature current\n", + "\n", + "E = V_t + I_a*R_a \t\t\t#Induced emf\n", + "\n", + "# Results\n", + "print 'Induced e.m.f to supply the 5kW load is %.2f V'%(E)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced e.m.f to supply the 5kW load is 254.95 V\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.9 page no : 63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V_t = 250. \t\t\t#terminal voltage\n", + "P = 10.*10**3 \t\t\t#10kW power of generator\n", + "I_L = P/V_t \t\t\t#load current\n", + "I_a = I_L \t \t\t#As seperately excited\n", + "V_brush = 2.*2 \t\t\t# 2 * no of brushes\n", + "\n", + "E = 255. \t\t\t#on full load\n", + "\n", + "# Calculations\n", + "R_a = (E-V_t-V_brush)/I_a \t\t\t#Because E = V_t+ I_a*R_a + V_brush\n", + "\n", + "# Results\n", + "print 'Armature resistance of generator is %.3f ohm'%(R_a)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature resistance of generator is 0.025 ohm\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.10 page no : 64" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "R_a = 0.5\n", + "R_se = 0.03 \t\t\t#resimath.tance due to armature and series field winding\n", + "V_brush = 2. \t\t\t#brush drop\n", + "N = 1500. \t\t\t#generator speed in r.p.m\n", + "coils = 540.\n", + "turns_per_coil = 6.\n", + "\n", + "# Calculations\n", + "total_turns = coils*turns_per_coil\n", + "Z = 2*total_turns \t\t\t#Total conductors\n", + "I_a = 50 \t\t\t#armature current\n", + "\n", + "phi = 2*10**-3 \t\t\t#flux per pole in webers\n", + "E = phi*N*Z/(60) \t\t\t#A = P for lap-wound and they cancel out\n", + "V_t = E- (I_a*(R_a+R_se) + V_brush) \t\t\t#Because E = V_t+ I_a*R_a + V_brush\n", + "\n", + "# Results\n", + "print 'Terminal voltage is %.1f V'%(V_t)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Terminal voltage is 295.5 V\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.11 page no : 65" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V_t = 225. \t\t\t#voltage across winding\n", + "R_a = 0.04 \t\t\t#armature resistance\n", + "R_sh = 90 \t\t\t#shunt resistance\n", + "R_se = 0.02\t\t\t#resistance of series field winding\n", + "I_L = 75. \t\t\t#load current\n", + "\n", + "# Calculations\n", + "#E -I_a*R_a = V_t+I_L*R_se \n", + "I_sh = (V_t+I_L*R_se)/R_sh \t\t\t#current through shunt field winding\n", + "\n", + "I_a = I_L + I_sh \t\t\t #armature current \n", + "E = V_t+ I_a*R_a+I_L*R_se \t\t\t#induced emf\n", + "\n", + "# Results\n", + "print 'Generated voltage is %.1f V'%(E)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Generated voltage is 229.6 V\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.12 page no : 76" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "R_sh = 53. \t\t\t#resistance of field winding\n", + "V_t = 100. \t\t\t#terminal voltage \n", + "I_sh = V_t/R_sh \t\t\t#shunt current\n", + "I_f = I_sh\n", + "R_a = 0.1 \t\t\t#armature resistance\n", + "E_o = 143. \t\t\t# for I_sh = I_f = 1.8867 as obtained from graph\n", + "\n", + "# Calculations\n", + "I_a = (E_o-V_t)/R_a \t\t\t#Because E_o = V_t + I_a*R_a\n", + "I_L = I_a-I_sh \t\t\t#no load current\n", + "\n", + "# Results\n", + "print 'Note: Open circuit voltage was obtained as followsE_o = R_sh*I_f \t\t\t# y = mx+c form with c = 0 and R_sh = 53Hence%( a line with slope 53 through origin is made to intersect OCC at 150 V'\n", + "print 'Therefore, Open circuit voltage is 150 V'\n", + "print 'No load current is %.4f A '%(I_L)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Note: Open circuit voltage was obtained as followsE_o = R_sh*I_f \t\t\t# y = mx+c form with c = 0 and R_sh = 53Hence%( a line with slope 53 through origin is made to intersect OCC at 150 V\n", + "Therefore, Open circuit voltage is 150 V\n", + "No load current is 428.1132 A \n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.13 page no : 79" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "#part(1)\n", + "E_o = 240. \t\t\t#on no-load\n", + "\n", + "# Calculations and Results\n", + "#Draw horizontal line from 240 V, to intersect OCC at A. corresponding I_f is 2.25 A\n", + "#The slope pf OA is corresponding R_sh\n", + "I_f = 2.25 \t\t\t#Corresponds to 240 V when intersected OCC\n", + "R_sh = E_o/I_f \t\t\t#shunt resistance\n", + "print 'i)Field resistance that gives 240 V on no-load is %.2f ohms '%(R_sh)\n", + "\n", + "#Part(ii)\n", + "N1 = 1000. \t\t\t#speed of shunt generator in rpm\n", + "I_f = 1.\n", + "\n", + "#Draw line OP math.tangential to OCC at N1 = 1000 r.p.m.\n", + "#Select I_f = 1A i.e. point R\n", + "#Draw vertical from R to intersect OP at S and OA at T....this gives RT = 105 and RS = 159\n", + "#At critcal speed generator just fails to build up\n", + "\n", + "RT = 105.\n", + "RS = 159.\n", + "N_C = N1*RT/RS \t\t\t#Critical speed\n", + "print 'ii)Critical speed is %.2f r.p.m '%(N_C)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Field resistance that gives 240 V on no-load is 106.67 ohms \n", + "ii)Critical speed is 660.38 r.p.m \n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.14 page no : 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "P = 4. \t\t\t#number of poles\n", + "A = 2. \t\t\t#because wave wound\n", + "Z = 792 \t\t\t#No of conductors\n", + "phi = 0.012 \t\t\t#flux per pole in weber\n", + "E_g = 240 \t\t\t#on no-load\n", + "\n", + "# Calculations\n", + "#running speed\n", + "N = E_g*60*A/(phi*P*Z) \t\t\t#becuase E_g = phi*P*N*Z/(60*A)\n", + "\n", + "# Results\n", + "print 'Required running speed is %.3f r.p.m'%(N)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required running speed is 757.576 r.p.m\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.15 page no : 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "#open circuit condition\n", + "I_L = 0. \t\t\t#because of open circuit\n", + "V_t = 127. \t\t\t#terminal voltage\n", + "E_g = V_t \t\t\t#because I_L = 0\n", + "\n", + "# Calculations\n", + "#load condition\n", + "V_t = 120\n", + "R_sh = 15.\n", + "R_a = 0.02 \t\t\t#shunt and armature resistance\n", + "I_sh1 = V_t/R_sh \t\t\t#current through shunt winding in loaded condition\n", + "\n", + "I_L = (E_g-V_t)/R_a - I_sh1 \t\t\t#because I_a1 = I_L+I_sh1 and E_g = V_t + I_a1*R_a\n", + "\n", + "# Results\n", + "print 'Load current is %.0f A'%(I_L)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Load current is 342 A\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.16 page no : 81" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V_t = 550. \t\t\t#Terminal voltage\n", + "R_lamp = 500. \t\t\t#Each lamp\n", + "I_lamp = V_t/R_lamp \t\t\t#each lamp ; V_t because all lamps are in parallel\n", + "\n", + "# Calculations\n", + "I_L = 20*I_lamp \t\t\t#there exist 20 lamps\n", + "R_sh = 25.\n", + "R_a = 0.06\n", + "R_se = 0.04 \t\t\t#resistance of shunt winding,armature,series field\n", + "I_sh = V_t/R_sh \t\t\t#current throough shunt winding\n", + "I_a = I_L+I_sh\t\t\t#armature current\n", + "E = V_t + I_a*(R_a+R_se) \t\t\t#generated emf\n", + "\n", + "# Results\n", + "print 'Armature current and generated e.m.f is %.0f A and %.1f V respectively '%(I_a,E )\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature current and generated e.m.f is 44 A and 554.4 V respectively \n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.17 page no : 82" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "P = 4. \t\t\t#number of poles\n", + "A = P \t\t\t# because of lap wound\n", + "N = 750. \t\t\t#speed in rpm\n", + "Z = 720. \t\t\t#number of armature conductors\n", + "phi = 30.*10**-3 \t\t\t#flux per pole in weber\n", + "R_sh = 200.\n", + "R_a = 0.4\n", + "R_L = 15. \t\t\t#resistance of shunt winding,armature,series field\n", + "E = phi*P*N*Z/(60*A) \t\t\t#generated emf\n", + "\n", + "# Calculations\n", + "#solving the following equations for V_t\n", + "#E = V_t + I_a*R_a\n", + "#E = V_t + (I_L + I_sh)*R_a\n", + "#E = V_t + ((V_t/R_L) + (V_t/R_sh))*R_a\n", + "V_t = E/(1+(R_a/R_L)+(R_a/R_sh))\n", + "\n", + "# Results\n", + "print 'Terminal voltage = %.4f V'%(V_t)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Terminal voltage = 262.4757 V\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.18 page no : 83" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "P = 6. \t\t\t#number of poles\n", + "A = 2. \t\t\t# because of wave wound\n", + "N_1 = 300. \t\t\t#speed of generator\n", + "Z = 600. \t\t\t#number of armature conductors\n", + "phi_1 = 0.06 \t\t\t#flux per pole in webers \n", + "\n", + "# Calculations and Results\n", + "E_g1 = phi_1*P*N_1*Z/(60*A) \t\t\t#generated emf\n", + "print 'Emf generated is %.0f V'%(E_g1)\n", + "\n", + "phi_2 = 0.055 \t\t\t#new flux per pole \n", + "E_g2 = 550.\t\t\t# new generated emf\n", + "N_2 = E_g2/(phi_2*P*Z/(60*A)) \t\t\t#new speed of generator\n", + "print 'Required speed is %.2f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Emf generated is 540 V\n", + "Required speed is 333.33 r.p.m\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.19 page no : 84" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "\n", + "print 'Refer to code for explanation'\n", + "\n", + "# Variables\n", + "N_1 = 300.\n", + "N_2 = 375. \t\t\t#generator speeds\n", + "\n", + "#E_g2 = E_g1*(N_2/N_1)\n", + "#using this new table OCC at N_2 = 375 is made\n", + "#Draw a line with slope R_sh = 40 through origin which cuts this OCC at 248\n", + "#I_f_table = [0,2,3,4,5,6,7]\n", + "#Arm_vol_table = [9.375,115,165,202.5,228.75,237.5,265]\n", + "\n", + "#part(i)\n", + "#at V = 200 volts, I_f = 3.9 from the graph\n", + "V = 200.\n", + "I_f = 3.9\n", + "\n", + "# Calculations and Results\n", + "R_sh2 = V/I_f\n", + "R_sh = 40.\n", + "print 'Additional resistance required is %.3f ohms '%(R_sh2-R_sh)\n", + "\n", + "#part(ii)\n", + "V_t = 200.\n", + "I_f = V_t/R_sh\n", + "E_g = 228.75 \t\t\t#For this I_f from the table \n", + "R_a = 0.4\n", + "I_a = (E_g-V_t)/R_a \t\t\t#Because E_g = V_t + I_a*R_a\n", + "I_L = I_a-I_f\n", + "print 'Load current supplied by the generator is %.3f A'%(I_L)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Refer to code for explanation\n", + "Additional resistance required is 11.282 ohms \n", + "Load current supplied by the generator is 66.875 A\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.20 page no : 86" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "I_a = 750. \t\t\t#full load current \n", + "Pole = 6. \n", + "A = Pole \t\t\t#lap winding\n", + "I = I_a/A \t\t\t#Full-load current per path\n", + "Z = 900. \t\t\t#no of conductors\n", + "lambda1 = 1.4 \t\t\t#leakage coefficient\n", + "theta_e = 21. \t\t\t#lead angle in degrees electrical\n", + "\n", + "# Calculations\n", + "theta_m = theta_e/(Pole/2) \t\t\t#lead angle in degrees mechanical\n", + "amp_turns_PP_d = Z*I*theta_m/360 \t\t\t#demagnetising ampere turns per pole\n", + "amp_turns_PP_c = Z*I*(1./(2*Pole)-theta_m/360) \t\t\t#cross-magnetising ampere turns per pole\n", + "balance_turns = amp_turns_PP_d*lambda1/I_a \t\t\t#series turns required to balance demagnetising component\n", + "\n", + "# Results\n", + "print 'i) De-magnetising ampere-turns per pole is %.1f'%(amp_turns_PP_d)\n", + "print 'ii) Cross-magnetising ampere-turns per pole is %.1f'%(amp_turns_PP_c)\n", + "print 'iii)Turns required to balance demagnetising component is %.0f'%(balance_turns)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i) De-magnetising ampere-turns per pole is 2187.5\n", + "ii) Cross-magnetising ampere-turns per pole is 7187.5\n", + "iii)Turns required to balance demagnetising component is 4\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.21 page no : 87" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "Pole = 4. \n", + "Z = 32. \t\t\t#no of conductors\n", + "coil_sides = Z \n", + "segments = 16.\n", + "pole_pitch = Z/Pole\n", + "slots = 16.\n", + "slots_per_pole = slots/Pole\n", + "\n", + "# Calculations\n", + "#for Simplex lap winding\n", + "y_b = pole_pitch+1 \t\t\t#back pitch\n", + "y_f = pole_pitch-1 \t\t\t#front pitch\n", + "\n", + "y_c = 1 \t\t\t#Commutator pitch; Note that it is positive and it is progressive type of Simplex lap winding\n", + "\n", + "# Results\n", + "print 'WINDING TABLE: 1<- 10-> 3<- 12-> 5<- 14-> 7<- 16-> 9<- 18-> 11<- 20->13<- 22-> 15<- 24-> 17<- 26->19<- 28-> 21<- 30-> 23<- 32->25<- 2-> 27<- 4-> 29<- 6->31<- 8->1 '\n", + "print 'Note that <- indicates back connection with y_back = %.0f and -> indicates front connection with y_front = %.0f'%(y_b,y_f)\n", + "\n", + "print 'Another form of winding table:'\n", + "\n", + "print ' BACK CONNECTIONS FRONT CONNECTIONS'\n", + "\n", + "print ' 1 to 1+9 = 10 -> 10 to 10-7 = 3'\n", + "print ' 3 to 3+9 = 12 -> 12 to 12-7 = 5'\n", + "print ' 5 to 5+9 = 14 -> 14 to 14-7 = 7'\n", + "print ' 7 to 7+9 = 16 -> 16 to 16-7 = 9'\n", + "print ' 9 to 9+9 = 18 -> 18 to 18-7 = 11'\n", + "print ' 11 to 11+9 = 20 -> 20 to 20-7 = 13'\n", + "print ' 13 to 13+9 = 22 -> 22 to 22-7 = 15'\n", + "print ' 15 to 15+9 = 24 -> 24 to 24-7 = 17'\n", + "print ' 17 to 17+9 = 26 -> 26 to 26-7 = 19'\n", + "print ' 19 to 19+9 = 28 -> 28 to 28-7 = 21'\n", + "print ' 21 to 21+9 = 30 -> 30 to 30-7 = 23'\n", + "print ' 23 to 23+9 = 32 -> 32 to 32-7 = 25'\n", + "print ' 25 to 25+9 = 34 = 34-32 = 2 -> 2 to 34-7 = 27'\n", + "print ' 27 to 27+9 = 36 = 36-32 = 4 -> 4 to 36-7 = 29'\n", + "print ' 29 to 29+9 = 38 = 38-32 = 6 -> 6 to 38-7 = 31'\n", + "print ' 31 to 31+9 = 40 = 40-32 = 4 -> 8 to 40-7 = 33 -32 = 1'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "WINDING TABLE: 1<- 10-> 3<- 12-> 5<- 14-> 7<- 16-> 9<- 18-> 11<- 20->13<- 22-> 15<- 24-> 17<- 26->19<- 28-> 21<- 30-> 23<- 32->25<- 2-> 27<- 4-> 29<- 6->31<- 8->1 \n", + "Note that <- indicates back connection with y_back = 9 and -> indicates front connection with y_front = 7\n", + "Another form of winding table:\n", + " BACK CONNECTIONS FRONT CONNECTIONS\n", + " 1 to 1+9 = 10 -> 10 to 10-7 = 3\n", + " 3 to 3+9 = 12 -> 12 to 12-7 = 5\n", + " 5 to 5+9 = 14 -> 14 to 14-7 = 7\n", + " 7 to 7+9 = 16 -> 16 to 16-7 = 9\n", + " 9 to 9+9 = 18 -> 18 to 18-7 = 11\n", + " 11 to 11+9 = 20 -> 20 to 20-7 = 13\n", + " 13 to 13+9 = 22 -> 22 to 22-7 = 15\n", + " 15 to 15+9 = 24 -> 24 to 24-7 = 17\n", + " 17 to 17+9 = 26 -> 26 to 26-7 = 19\n", + " 19 to 19+9 = 28 -> 28 to 28-7 = 21\n", + " 21 to 21+9 = 30 -> 30 to 30-7 = 23\n", + " 23 to 23+9 = 32 -> 32 to 32-7 = 25\n", + " 25 to 25+9 = 34 = 34-32 = 2 -> 2 to 34-7 = 27\n", + " 27 to 27+9 = 36 = 36-32 = 4 -> 4 to 36-7 = 29\n", + " 29 to 29+9 = 38 = 38-32 = 6 -> 6 to 38-7 = 31\n", + " 31 to 31+9 = 40 = 40-32 = 4 -> 8 to 40-7 = 33 -32 = 1\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.22 page no : 89" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from numpy import *\n", + "\n", + "# Variables\n", + "Z = 496. \t\t\t#no of conductors\n", + "P = 4. \t\t\t#poles\n", + "slots = 31.\n", + "coilsides_per_slot = 4.\n", + "coilsides = slots*coilsides_per_slot\n", + "coils = coilsides/2\n", + "turns = Z/2\n", + "turns_per_coil = turns/coils\n", + "\n", + "# Calculations\n", + "y_c = array([(Z-2)/P, (Z+2)/P]) \t\t\t#commutator pitch\n", + "coils_active = (Z/(2*P))-1 \t\t\t# because y_c didnt turn out to be integer, 1 coil was made inactive/dummy\n", + "segments = coils_active \t\t\t#no of commutative segments\n", + "Y_A = [ (segments+1)/(P/2), (segments-1)/(P/2) ]\n", + "Y_A = Y_A[0] \t\t\t#Y_A(2) is discarded because of progressive wave winding\n", + "y_f = 29.\n", + "y_b = 33. \t\t\t#front and back pitch ; note that Y_A = (y_b+y_f)/2\n", + "resultant_pitch = 2*Y_A \t\t\t#because Y_A = (y_b+y_f)/2 and resultant pitch = y_b+ y_f\n", + "\n", + "# Results\n", + "print 'i) Total number of coils = %.0f'%(coils)\n", + "print 'ii) Turns per coils = %.0f'%(turns_per_coil)\n", + "print 'iii) Commutator pitch = %.0f'%((y_c[0]+y_c[1])/2)\n", + "print 'iv) Back pitch = %.0f front pitch = %.0f total pitch = %.0f'%(y_b,y_f,resultant_pitch)\n", + "print 'v) No of commutator segments = %.0f'%(segments)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i) Total number of coils = 62\n", + "ii) Turns per coils = 4\n", + "iii) Commutator pitch = 124\n", + "iv) Back pitch = 33 front pitch = 29 total pitch = 62\n", + "v) No of commutator segments = 61\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.23 page no : 90" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "slots = 13.\n", + "Pole = 4.\n", + "conductors_per_slot = 2.\n", + "Z = conductors_per_slot*slots\n", + "Y_A = (Z+2)/Pole \t\t\t#For progressive type wave winding\n", + "\n", + "# Calculations\n", + "#Since Y_A = (y_b+y_f)/2, we let y_b = y_f\n", + "y_b = Y_A\n", + "y_f = y_b \t\t \t#because y_b = Y_A/2\n", + "\n", + "segments = 13. \t\t\t#commutator segments\n", + "\n", + "# Results\n", + "print 'WINDING TABLE: 1<- 8-> 15<- 22-> 3<- 10->17<- 24-> 5<- 12-> 19<- 26-> 7<- 14-> 21<- 2-> 9<- 16->23<- 4-> 11<- 18-> 25<- 6->13<- 20-> 1 '\n", + "print 'Note that <- indicates back connection with y_back = %.0f and -> indicates front connection with y_front = %.0f'%(y_b,y_f)\n", + "\n", + "print 'Another form of winding table:'\n", + "\n", + "print ' BACK CONNECTIONS FRONT CONNECTIONS'\n", + "\n", + "print ' 1 to 1+7 = 8 -> 8 to 8+7 = 15'\n", + "print ' 15 to 15+7 = 22 -> 22 to 22+7 = 29 -26 = 3'\n", + "print ' 3 to 3+7 = 10 -> 10 to 10+7 = 17'\n", + "print ' 17 to 17+7 = 24 -> 24 to 24+7 = 31 -26 = 5'\n", + "print ' 5 to 5+7 = 14 -> 12 to 12+7 = 19'\n", + "print ' 19 to 19+7 = 26 -> 26 to 26+7 = 33 -26 = 7'\n", + "print ' 7 to 7+7 = 14 -> 14 to 14+7 = 21'\n", + "print ' 21 to 21+7 = 28 -26 = 2 -> 2 to 2+7 = 9'\n", + "print ' 9 to 9+7 = 16 -> 16 to 16+7 = 23 '\n", + "print ' 23 to 23+7 = 30 -26 = 4 -> 4 to 4+7 = 11'\n", + "print ' 11to 11+7 = 18 -> 18 to 18+7 = 25'\n", + "print ' 25 to 25+7 = 32 -26 = 6 -> 6 to 6+7 = 13'\n", + "print ' 13 to`13+7 = 20 -> 20 to 20+7 = 27 -26 = 1'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "WINDING TABLE: 1<- 8-> 15<- 22-> 3<- 10->17<- 24-> 5<- 12-> 19<- 26-> 7<- 14-> 21<- 2-> 9<- 16->23<- 4-> 11<- 18-> 25<- 6->13<- 20-> 1 \n", + "Note that <- indicates back connection with y_back = 7 and -> indicates front connection with y_front = 7\n", + "Another form of winding table:\n", + " BACK CONNECTIONS FRONT CONNECTIONS\n", + " 1 to 1+7 = 8 -> 8 to 8+7 = 15\n", + " 15 to 15+7 = 22 -> 22 to 22+7 = 29 -26 = 3\n", + " 3 to 3+7 = 10 -> 10 to 10+7 = 17\n", + " 17 to 17+7 = 24 -> 24 to 24+7 = 31 -26 = 5\n", + " 5 to 5+7 = 14 -> 12 to 12+7 = 19\n", + " 19 to 19+7 = 26 -> 26 to 26+7 = 33 -26 = 7\n", + " 7 to 7+7 = 14 -> 14 to 14+7 = 21\n", + " 21 to 21+7 = 28 -26 = 2 -> 2 to 2+7 = 9\n", + " 9 to 9+7 = 16 -> 16 to 16+7 = 23 \n", + " 23 to 23+7 = 30 -26 = 4 -> 4 to 4+7 = 11\n", + " 11to 11+7 = 18 -> 18 to 18+7 = 25\n", + " 25 to 25+7 = 32 -26 = 6 -> 6 to 6+7 = 13\n", + " 13 to`13+7 = 20 -> 20 to 20+7 = 27 -26 = 1\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.24 page no : 93" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "P = 4.\n", + "I_L = 150.\n", + "N = 1500. \t\t\t#commutator speed in rpm\n", + "n_s = N/60. \t\t\t#commutator speed in r.p.s\n", + "W_b = 1.2 \t\t\t#Brush pitch\n", + "W_m = 0\t\t\t#Pitch of mica insulation\n", + "L = 0.05*10**-3 \t\t\t#inducmath.tance of armature coils in henry\n", + "A = P \t\t\t#A = P for lap wound\n", + "segments = 64.\n", + "\n", + "# Calculations\n", + "v = n_s*segments \t\t\t#peripheral speed in segments per second\n", + "T_c = (W_b-W_m)/v \t\t\t#Time of commutation\n", + "I = I_L/A \t\t\t#current through each conductor\n", + "E = L*2*I/T_c \t\t\t#Linear commutation\n", + "E2 = 1.11*L*2*I/T_c \t\t\t#Sinusoidal commutation\n", + "\n", + "# Results\n", + "print 'Reactive voltage linear commutation) is %.0f V'%(E)\n", + "print 'Reactive voltage math.sinusoidal commutation) is %.2f V'%(E2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Reactive voltage linear commutation) is 5 V\n", + "Reactive voltage math.sinusoidal commutation) is 5.55 V\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.25 page no : 94" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "P = 4. \t\t\t#Pole\n", + "Z = 386. \t\t\t#no of wave connected conductors\n", + "A = 2. \t\t\t#Wave winding\n", + "R_a = 1.\n", + "R_sh = 100.\n", + "R_L = 40 \t\t\t#Armature ,shunt field and load resistance\n", + "phi = 25.*10**-3 \t\t\t#flux per pole in weber\n", + "N = 1000. \t\t\t#speed in rpm\n", + "\n", + "\n", + "# Calculations\n", + "E_g = (phi*P*N*Z)/(60*A) \t\t\t#generated emf\n", + "\n", + "#Solving following equations for V_t\n", + "#E_g = V_t+I_a*R_a\n", + "#I_a = (I_L+I_sh) I_L = V_t/R_L I_sh = V_t/R_sj\n", + "#E_g = V_t(1 + (R_a/R_L) + (R_a/R_sh)\n", + "V_t = E_g/(1 + (R_a/R_L) + (R_a/R_sh))\n", + "\n", + "I_L = V_t/R_L \t\t\t# load current\n", + "I_sh = V_t/R_sh \t\t\t# current through shunt field resistance\n", + "\n", + "# Results\n", + "I_a = I_L+I_sh \t\t\t#armature current \n", + "print 'armature current is is %.4f A'%(I_a)\n", + "\n", + "output_power = V_t*I_L\n", + "print 'output power is %.3f W'%(output_power)\n", + "\n", + "# Note :answer obtained will not match with textbook answer because I_L = V_t/R_L = 310.79/40 = 7.77 \n", + "#Awhile its taken as 8.045 A in textbook'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "armature current is is 10.8776 A\n", + "output power is 2414.746 W\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.26 page no : 94" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "I = 40. \t\t \t#current PER conductor\n", + "W_b = 3.\n", + "W_m = 0.\t\t\t #brush width and width of mica insulation\n", + "N = 600. \t\t\t #commutator speed in rpm \n", + "n_s = N/60 \t\t\t #commutator speed in rps\n", + "L = 0.15*10**-3 \t\t\t#self inducmath.tance in Henry\n", + "segments = 50. \n", + "v = n_s*segments \t\t\t#peripheral speed in segments per second\n", + "T_c = (W_b-W_m)/v \t\t\t#time of commutation\n", + "\n", + "# Calculations\n", + "E = L*2*I/T_c \t\t\t#Linear commutation\n", + "E2 = 1.11*L*2*I/T_c \t\t\t#Sinusoidal commutation\n", + "\n", + "# Results\n", + "print 'Reactive voltage linear commutation) is %.0f volts'%(E)\n", + "print 'Reactive voltage math.sinusoidal commutation) is %.2f volts'%(E2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Reactive voltage linear commutation) is 2 volts\n", + "Reactive voltage math.sinusoidal commutation) is 2.22 volts\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.27 page no : 96" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 400.\n", + "P = 6. \t\t\t #Poles\n", + "A = P \t\t \t#For lap wound\n", + "output_power = 250.*10**3\n", + "R_sh = 200. \t\t\t#shunt field circuit resistance\n", + "Z = 720. \t\t\t#number of lap wound conductors\n", + "\n", + "theta_m = 2.5 \t\t\t#brush lead angle in degree mechanical\n", + "I_L = output_power/V\n", + "V_sh = V\n", + "\n", + "# Calculations\n", + "I_sh = V_sh/R_sh \t\t\t#Current through shunt field circuit resistance\n", + "I_a = I_L+I_sh \t\t\t#armature currrent\n", + "I = I_a/P\n", + "\n", + "#Part(i)\n", + "amp_turns_PP_d = Z*I*theta_m/360\t\t\t#demagnetising ampere turns per pole\n", + "#Part(ii)\n", + "amp_turns_PP_c = Z*I*(1/(2*P)-theta_m/360) \t\t\t#cross-magnetising ampere turns per pole\n", + "\n", + "# Results\n", + "print 'i) De-magnetising ampere-turns per pole is %.1f'%(amp_turns_PP_d)\n", + "print 'ii) Cross-magnetising ampere-turns per pole is %.1f'%(amp_turns_PP_c)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i) De-magnetising ampere-turns per pole is 522.5\n", + "ii) Cross-magnetising ampere-turns per pole is 5747.5\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.28 page no : 96" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "I_L = 100.\n", + "P = 4. \t\t\t #Poles\n", + "A = P \t\t\t #for lap wound armature\n", + "W_b = 1.4\n", + "W_m = 0. \t\t\t#Brush width and width of mica insulation\n", + "N = 1400.\t\t\t#armature speed in r.p.m\n", + "segments = 64. \t\t\t#no of commutator segments\n", + "L = 0.05*10**-3 \t\t\t#inducmath.tance of armature coil in henry\n", + "\n", + "# Calculations\n", + "n_s = N/60 \t\t\t#speed in r.p.s\n", + "v = n_s*segments \t\t\t#Segments per second\n", + "T_c = (W_b-W_m)/v \t\t\t#time of commutation\n", + "I = I_L/A \t\t\t#Current through conductor\n", + "E = L*2*I/T_c \t\t\t#Linear commutation\n", + "\n", + "# Results\n", + "print 'Reactive voltage considering linear commutation is %.2f volts'%(E)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Reactive voltage considering linear commutation is 2.67 volts\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.29 page no : 97" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "P = 8. \t\t \t#Poles\n", + "A = 2. \t\t \t#Wave wound armature\n", + "Z = 480. \t\t\t#number of armature conductors\n", + "I_a = 200.\n", + "I = I_a/A\n", + "\n", + "# Calculations and Results\n", + "#Part(i)\n", + "theta_m = 0. \t\t\t#Geometric nuetral axis\n", + "amp_turns_PP_d = Z*I*theta_m/360 \t\t\t#De-magnetising ampere-turns per pole\n", + "amp_turns_PP_c = Z*I*(1/(2*P)-theta_m/360) \t\t\t#Cross-magnetising ampere-turns per pole\n", + "print 'Parti)De-magnetising ampere-turns per pole is %.0f'%(amp_turns_PP_d)\n", + "print 'Cross-magnetising ampere-turns per pole is %.0f'%(amp_turns_PP_c)\n", + "\n", + "#Part(ii)\n", + "theta_e2 = 6. \t\t\t#angle shift of brushes in degrees electrical\n", + "theta_m2 = theta_e2/(P/2) \t\t\t#angle shift of brushes in degrees mechanical\n", + "amp_turns_PP_d2 = Z*I*theta_m2/360 \t\t\t#De-magnetising ampere-turns per pole\n", + "amp_turns_PP_c2 = Z*I*(1/(2*P)-theta_m2/360) \t\t\t#Cross-magnetising ampere-turns per pole\n", + "print 'Partii)De-magnetising ampere-turns per pole is %.0f'%(amp_turns_PP_d2)\n", + "print 'Cross-magnetising ampere-turns per pole is %.0f'%(amp_turns_PP_c2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Parti)De-magnetising ampere-turns per pole is 0\n", + "Cross-magnetising ampere-turns per pole is 3000\n", + "Partii)De-magnetising ampere-turns per pole is 200\n", + "Cross-magnetising ampere-turns per pole is 2800\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.30 page no : 98" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "P_input = 7.46*10**3\n", + "V = 230.\n", + "Pole = 8.\n", + "Z = 188. \t\t\t#number of armature consuctors\n", + "I_L = P_input/V\n", + "theta_m = 7.5 \t\t\t#brush lead angle in degree mechanical\n", + "\n", + "A = 2. \t\t\t# assumed wave wound because of low-current and high voltage\n", + "I = I_L/A\n", + "\n", + "#Part(i)\n", + "amp_turns_PP_d = Z*I*theta_m/360 \t\t\t#De-magnetising ampere-turns per pole\n", + "#Part(ii)\n", + "amp_turns_PP_c = Z*I*(1/(2*Pole)-theta_m/360) \t\t\t#Cross-magnetising ampere-turns per pole\n", + "\n", + "print 'De-magnetising ampere-turns per pole is %.2f'%(amp_turns_PP_d)\n", + "print 'Cross-magnetising ampere-turns per pole is %.2f'%(amp_turns_PP_c)\n", + "\n", + "# note : The difference in answer occured because I is approximated to 16 in last 2 steps in book\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "De-magnetising ampere-turns per pole is 63.52\n", + "Cross-magnetising ampere-turns per pole is 127.04\n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.31 page no : 99" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "N_1 = 1200. \t\t\t#initial speed \n", + "I_L1 = 200. \t\t\t#initial load current\n", + "V_t1 = 125.\n", + "N_2 = 1000. \t\t\t#altered speed\n", + "R_a = 0.04 \t\t\t#armature resistance\n", + "V_brush = 2. \t\t\t#brush drop\n", + "\n", + "# Calculations\n", + "# Initial Load\n", + "I_a1 = I_L1\n", + "E_g1 = V_t1+I_a1*R_a+V_brush \t\t\t#induced emf\n", + "\n", + "E_g2 = E_g1*(N_2/N_1) \t\t\t#Because E_g proportional to N during constant flux\n", + "R_L = V_t1/I_L1 \t\t\t#Load resistance\n", + "\n", + "#Solving for I_L2 as follows\n", + "#V_t2 = R_L*I_L2 \t\t\t#I_a2 = I_L2\n", + "#V_t2 = E_g2-(I_L2*R_2 + V_brush)\n", + "I_L2 = (E_g2-V_brush)/(R_L+R_a) \t\t\t#new current\n", + "\n", + "# Results\n", + "print 'Load current at new speed is %.4f A'%(I_L2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Load current at new speed is 166.1654 A\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/DC_Machines_and_Synchronous_Machines/ch2.ipynb b/DC_Machines_and_Synchronous_Machines/ch2.ipynb new file mode 100755 index 00000000..b87a9190 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/ch2.ipynb @@ -0,0 +1,2010 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:78f41af8e7d3182972251bae0a04df7a30b3aeb555cc290301b49daf9f643c37" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 2 : D.C. Motors" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.1 page no : 5" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "\n", + "# Variables\n", + "V = 220.\n", + "I_a = 30. \t\t\t#armature currnet\n", + "R_a = 0.75 \t\t\t#Armature resistance\n", + "\n", + "# Calculations\n", + "E_b = V - I_a*R_a \t\t\t# Since V = E_b+ I_a*R_a\n", + "\n", + "\n", + "# Results\n", + "print 'Induced EMF or back EMF in the motor is %.1f V'%(E_b)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced EMF or back EMF in the motor is 197.5 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.2 page no : 6" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "Pole = 4.\n", + "A = Pole \t\t\t#for lap winding\n", + "V = 230.\n", + "Z = 250. \t\t\t#number of armature conductors\n", + "phi = 30.*10**-3 \t\t\t#flux per pole in weber\n", + "I_a = 40.\n", + "R_a = 0.6 \t\t\t#Armature resistance\n", + "\n", + "# Calculations \n", + "E_b = V - I_a*R_a \t\t\t# Since V = E_b+ I_a*R_a\n", + "N = E_b * 60*A/(phi*Pole*Z) \t\t\t#because E_b = phi*P*N*Z/(60*A)\n", + "\n", + "# Results\n", + "print 'Back emf is %.0f V and running speed is %.0f rpm'%(E_b,N)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Back emf is 206 V and running speed is 1648 rpm\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.3 page no : 9" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "Pole = 4.\n", + "A = Pole \t\t\t#for lap winding\n", + "Z = 480.\t\t\t#number of armature conductors\n", + "phi = 20.*10**-3 \t\t\t#flux per pole in weber\n", + "I_a = 50. \t\t\t#Armature current\n", + "\n", + "# Calculations\n", + "T_a = 0.159*phi*I_a*Pole*Z/A \t\t\t#Gross torque developed by armature\n", + "\n", + "# Results\n", + "print 'Gross torque developed by armature is %.3f N-m'%(T_a)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Gross torque developed by armature is 76.320 N-m\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.4 page no : 10" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 4.\n", + "A = Pole \t\t\t#for lap winding\n", + "V = 230.\n", + "R_a = 0.8 \t\t\t#Armature resistance\n", + "N_0 = 1000. \t\t\t#no load speed in rpm\n", + "Z = 540. \t\t\t#number of armature conductors\n", + "phi = 25.*10**-3 \t\t\t#flux per pole in weber\n", + "\n", + "# Calculations and Results\n", + "E_b0 = phi*Pole*N_0*Z/(60*A) \t\t\t#induced emf\n", + "\n", + "#part(i)\n", + "print 'i)Induced e.m.f = %.0f V'%(E_b0)\n", + "\n", + "#part(ii)\n", + "I_a0 = (V- E_b0)/R_a \t\t\t#because V = E_b0+ I_a0*R_a\n", + "print 'ii)Armature current = %.2f A'%(I_a0)\n", + "\n", + "#part(iii)\n", + "stray_losses = E_b0*I_a0 \t\t\t#on no load ,power developed is fully power required to overcome strya losses\n", + "print 'iii)Stray loss = %.2f W'%(stray_losses)\n", + "\n", + "#part(iv)\n", + "T_f = E_b0*I_a0/(2*math.pi*N_0/60) \t\t\t#lost torque\n", + "print 'iv)Lost torque = %.3f N-m'%(T_f)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Induced e.m.f = 225 V\n", + "ii)Armature current = 6.25 A\n", + "iii)Stray loss = 1406.25 W\n", + "iv)Lost torque = 13.429 N-m\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.5 page no : 21" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "Pole = 4.\n", + "Z = 200. \t\t\t #No of armature conductors\n", + "A = 2. \t\t\t #wave connected armature\n", + "V = 250.\n", + "phi = 25.*10**-3 \t\t\t#flux per pole in weber\n", + "I_a = 60.\n", + "I_L = I_a \t \t\t#armature current\n", + "R_a = 0.15\n", + "R_se = 0.2 \t\t\t#resistances of armature and series field winding\n", + "\n", + "# Calculations\n", + "E_b = V - I_a*(R_a+R_se) \t\t\t#induced emf\n", + "N = E_b * 60*A/(phi*Pole*Z) \t\t\t#because E_b = phi*P*N*Z/(60*A)\n", + "\n", + "# Results\n", + "print 'Required speed is %.0f r.p.m'%(N)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required speed is 1374 r.p.m\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.6 page no : 22" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 250.\n", + "I_L = 20. \t\t\t#load current\n", + "R_a = 0.3\n", + "R_sh = 200. \t\t\t#Armature and shunt field winding\n", + "\n", + "# Calculations\n", + "I_sh = V/R_sh \t\t\t#shunt current\n", + "I_a = I_L-I_sh \t\t\t#armature current\n", + "E_b = V - I_a*R_a \t\t\t#emf generated\n", + "\n", + "# Results\n", + "print 'Armature current is %.2f A'%(I_a)\n", + "print 'Back e.m.f is %.3f V'%(E_b)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature current is 18.75 A\n", + "Back e.m.f is 244.375 V\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.7 page no : 22" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 220.\n", + "R_a = 0.3\n", + "R_sh = 110. \t\t\t#resistance of armature and shunt field winding\n", + "\n", + "#no load\n", + "N_0 = 1000. \t\t\t#no load speed in r.p.m\n", + "I_L0 = 6. \t\t\t#line current on no load\n", + "I_sh = V/R_sh \t\t\t#no load shnt current\n", + "I_a0 = I_L0 - I_sh \t\t\t#no load armature current\n", + "E_b0 = V - I_a0*R_a \t\t\t#no load induced emf\n", + "\n", + "# Calculations\n", + "#full load\n", + "I_sh_FL = V/R_sh\n", + "I_L_FL = 50 \t\t\t#line current at full load\n", + "I_a_FL = I_L_FL - I_sh_FL\t\t\t#full load armature current\n", + "E_b_FL = V - I_a_FL * R_a \t\t\t#full load induced emf\n", + "\t\t\t#using speed equation as treating phi as constant\n", + "N_FL = N_0 * (E_b_FL/E_b0)\n", + "\n", + "# Results\n", + "print 'Speed on full load is %.2f r.p.m'%(N_FL)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed on full load is 939.67 r.p.m\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.8 page no : 23" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "R_a = 0.2\n", + "R_se = 0.3 \t\t\t#resistance of armature and series field winding\n", + "#following variables correspond to load 1\n", + "V = 250.\n", + "N_1 = 800.\n", + "I_1 = 20.\n", + "I_a1 = I_1\n", + "I_se1 = I_a1\n", + "\n", + "# Calculations\n", + "E_b1 = V - I_a1*(R_a+R_se)\n", + "#following variables correspond to load 2\n", + "I_2 = 50.\n", + "I_a2 = I_2\n", + "E_b2 = V - I_a2*(R_a+R_se)\n", + "\n", + "#from speed equation it can be derived that\n", + "\n", + "N_2 = N_1 * (E_b2/E_b1) * (I_a1/I_a2)\n", + "\n", + "# Results\n", + "print 'Speed on motor on no load is %.0f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed on motor on no load is 300 r.p.m\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.9 page no : 31" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 250.\n", + "R_a = 0.3\n", + "R_sh = 200. \t\t\t#resistance of armature and shunt field winding\n", + "R_x = 150. \t\t\t#additional resistance added in series to field winding\n", + "I_L1 = 22.\n", + "I_sh1 = V/R_sh \t\t\t#initial shunt current before adding 150 ohms resistance\n", + "I_a1 = I_L1 - I_sh1 \t\t\t#initial armature current before adding 150 ohms resistance\n", + "N_1 = 1500. \t\t\t#initial speed before adding 150 ohms resistance\n", + "\n", + "# Calculations\n", + "#T (prop.) phi*I_a (prop.) I_sh*I_a and T_1 = T_2 and simplifying further \n", + "I_sh2 = V/(R_sh + R_x) \t\t\t#new shunt current\n", + "I_a2 = I_sh1*I_a1/I_sh2 \t\t\t#New armature current\n", + "\n", + "E_b1 = V - I_a1*R_a \t\t\t#induced emf before adding 150 ohms resistance\n", + "E_b2 = V - I_a2*R_a \t\t\t#new emf\n", + "\n", + "N_2 = N_1 * (E_b2/E_b1) * (I_sh1/I_sh2) \t\t\t#new speed\n", + "\n", + "# Results\n", + "print 'New armature current and speed are %.4f A and %.f r.p.m respectively'%(I_a2,N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New armature current and speed are 36.3125 A and 2575 r.p.m respectively\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.10 page no : 36" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 250.\n", + "R_a = 0.15\n", + "R_se = 0.1\n", + "R_x = 0.1 \t\t\t#Resimath.tance of armature , series field winding and extra resistance\n", + "N_1 = 800. \t\t\t#initial speed before load torque is increased\n", + "I_1 = 30.\n", + "I_a1 = I_1\n", + "I_se1 = I_1 \t\t\t#initial currents\n", + "\n", + "# Calculations\n", + "T_2_by_T_1 = 1 + (50./100) \t\t\t#50 percent increase as mentioned in question\n", + "I_se2_by_I_a2 = R_x/(R_x + R_se) \t\t\t#from the figure\n", + "\n", + "#T (prop.) phi*I_a (prop.) I_sh*I_a and T_1 = T_2 and simplifying ,solving further \n", + "I_a2 = math.sqrt(I_a1*I_se1*T_2_by_T_1/I_se2_by_I_a2) \t\t\t#new armature current\n", + "I_se2 = I_se2_by_I_a2 *I_a2 \t\t\t#new series field current\n", + "\n", + "E_b1 = V - I_a1*R_a - I_se1*R_se \t\t\t#indiced emf initially\n", + "E_b2 = V - I_a2*R_a - I_se2*R_se \t\t\t#new induced emf\n", + "N_2 = N_1 * (E_b2/E_b1) * (I_se1/I_se2) \t\t\t#required speed\n", + "\n", + "# Results\n", + "print 'The required running speed of motor is %.3f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The required running speed of motor is 912.743 r.p.m\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.11 page no : 38" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 220.\n", + "I_1 = 50.\n", + "I_a1 = I_1 \t\t\t#Currents before adding extra resistance\n", + "T_2_by_T_1 = 0.5\n", + "R_t = 0.15 \t\t\t#R_e + R_se = 0.15\n", + "\n", + "# Calculations\n", + "I_a2 = I_a1 * math.sqrt(T_2_by_T_1) \t\t\t#Because T (prop.) I_a**2\n", + "E_b1 = V-I_a1*(R_t) \t\t\t#induced emf before adding extra resistance\n", + "N_1 = 500.\n", + "N_2 = 300. \t\t\t#speeds before and adding extra resistance\n", + "\n", + "#N (prop.) E_b/phi (prop.) E_b/I_a\n", + "E_b2 = E_b1 *(I_a2/I_a1)*(N_2/N_1) \t\t\t#induced emf after adding resistance\n", + "R_x = (V-E_b2)/I_a2 -R_t \t\t\t#because E_b2 = V - I_a2*(R_a + R_se + R_x)\n", + "\n", + "# Results\n", + "print 'Desired extrea resistance = %.4f ohms '%(R_x)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Desired extrea resistance = 3.5225 ohms \n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.12 page no : 43" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "R_a = 1.\n", + "I_a = 1.2 \n", + "V = 50.\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "E_b = V - I_a*R_a\n", + "rot_loss_NL = E_b*I_a \t\t\t#no load rotational loss \n", + "print 'i)No load rotational losses = %.2f W'%(rot_loss_NL)\n", + "\n", + "#part(ii)\n", + "omega_2000 = 2*math.pi*2000/60 \t\t\t#angular velocity when speed of motor = 2000 rpm\n", + "K_m = E_b/omega_2000 \t\t\t#to determine K_m\n", + "V = 48.\n", + "omega_1800 = 2*math.pi*1800/60 \t\t\t#angular velocity when speed of motor = 1800 rpm\n", + "E_b = K_m*omega_1800\n", + "I_a = (V-E_b)/R_a \t\t\t#armature current\n", + "P_dev = E_b*I_a\t\t\t#power developed\n", + "motor_output = P_dev - rot_loss_NL\n", + "print 'ii)Motor output = %.f W'%(motor_output)\n", + "\n", + "#part(iii)\n", + "E_b = 0. \t\t\t#when motor stalls\n", + "V_stall = 20. \t\t\t#voltage during stalling\n", + "I_a = V_stall/R_a \t\t\t#armature current during stalling\n", + "T_stall = K_m*I_a \t\t\t#stalling torque\n", + "print 'iii)Stalling torque = %.2f N-m'%(T_stall)\n", + "print 'partii answer is slightly different due to inaccurate calculation of Power developed'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)No load rotational losses = 58.56 W\n", + "ii)Motor output = 121 W\n", + "iii)Stalling torque = 4.66 N-m\n", + "partii answer is slightly different due to inaccurate calculation of Power developed\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.13 page no : 49" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 120.\n", + "R_a = 0.2 \n", + "R_sh = 60. \t\t\t#armature and field resistance\n", + "I_L1 = 40.\n", + "N_1 = 1800. \n", + "\n", + "# Calculations\n", + "I_sh = V/R_sh\n", + "\n", + "I_a1 = I_L1 - I_sh \n", + "E_b1 = V -I_a1*R_a \t\t\t#Induced emf at half load\n", + "T2_by_T1 = 1./2 \n", + "I_a2 = I_a1*(T2_by_T1) \t\t\t#T (prop.)I_a\n", + "E_b2 = V- I_a2*R_a\t\t\t#induced emf at half load\n", + "N_2 = N_1 *(E_b2/E_b1) \t\t\t#N (prop.) E_b as phi is constant\n", + "\n", + "# Results\n", + "print 'Speed on half load condition is %.2f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed on half load condition is 1860.85 r.p.m\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.14 page no : 50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "R_a = 0.08\n", + "E_b1 = 242. \n", + "V = 250.\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "I_a1 = (V-E_b1)/R_a\n", + "print 'i)Armature current = %.0f A'%(I_a1)\n", + "\n", + "#part(ii)\n", + "N = 0.\n", + "E_b = 0. \t\t\t#because N = 0\n", + "I_a_start = V/R_a\n", + "print 'ii)Starting armature current = %.0f A'%(I_a_start)\n", + "\n", + "#part(iii)\n", + "I_a2 = 120.\n", + "E_b2 = V-I_a2*R_a\n", + "print 'iii)Back emf if armature current is changed to 120 A = %.1f V'%(E_b2)\n", + "\n", + "#part(iv)\n", + "I_a = 87.\n", + "N_m = 1500.\n", + "E_g = V + I_a*R_a \t\t\t#induced emf\n", + "N_g = N_m*(E_g/E_b1)\t\t\t#as E (prop.) N\n", + "print 'iv)Generator speed to deliver 87 A at 250 V = %.1f rpm'%(N_g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Armature current = 100 A\n", + "ii)Starting armature current = 3125 A\n", + "iii)Back emf if armature current is changed to 120 A = 240.4 V\n", + "iv)Generator speed to deliver 87 A at 250 V = 1592.7 rpm\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.15 page no : 51" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import *\n", + "\n", + "# Variables\n", + "shaft_output = 80.*746 \t\t\t#coverted to watts\n", + "eta = 80./100 \t\t\t#efficiency\n", + "V = 250.\n", + "N_1 = 1200.\n", + "R_a = 0.04\n", + "R_sh = 250. \t\t\t #armature and shunt field resistance\n", + "\n", + "# Calculations and Results\n", + "power_input = shaft_output/eta\n", + "I_L = power_input /V\n", + "I_sh = V / R_sh\n", + "I_a = I_L - I_sh\n", + "E_b1 = V - I_a*R_a\n", + "\n", + "gross_mechanical_power = E_b1*I_a \t\t\t#electrical equivalent of mechanical power developed\n", + "stray_losses = gross_mechanical_power - shaft_output\n", + "print 'Mechanical power developed on full load = %.3f kW'%(gross_mechanical_power/1000)\n", + "\n", + "#on no load shaft_output = 0 and entire gross power is used to overcome stray losses\n", + "Eb0_Ia0 = stray_losses\n", + "#E_b0 = V - I_a0*R_a ... solving for I_0\n", + "p = [R_a, -V, Eb0_Ia0]\n", + "ans = roots(p)\n", + "I_a0 = ans[1] \t\t\t#first root is ignored math.since its too large\n", + "I_L0 = I_sh+I_a0 \t\t\t#current drawn from supply\n", + "E_b0 = V - I_a0*R_a \n", + "\n", + "#From speed equation N (prop.) E_b\n", + "N_0 = N_1*(E_b0/E_b1)\n", + "print 'No load speed and current are %.4f rpm and %.2f A respectively'%(N_0,I_L0)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Mechanical power developed on full load = 70.812 kW\n", + "No load speed and current are 1250.9121 rpm and 45.85 A respectively" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.16 page no : 53" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 250.\n", + "P = 4. \n", + "R_a = 0.1 \n", + "R_sh = 124. \t\t\t#armature and shunt field resistance \n", + "I_L0 = 4.\n", + "N_0 = 1200.\n", + "I_L_1 = 61.\n", + "\n", + "# Calculations\n", + "I_sh = V/R_sh\n", + "I_a0 = I_L0-I_sh\n", + "V_brush = 2 \t\t\t#voltage loss due to brush\n", + "E_b0 = V - I_a0*R_a- V_brush\n", + "\n", + "I_a1 = I_L_1 - I_sh\n", + "E_b1 = V - I_a1*R_a -V_brush\n", + "\n", + "phi1_by_phi0 = 1-(5./100) \t\t\t#weakened by 5 %\n", + "N_1 = N_0 *(E_b1/E_b0) /phi1_by_phi0\n", + "\n", + "# Results\n", + "print 'Full load speed is %.3f r.p.m'%(N_1)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full load speed is 1234.102 r.p.m\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.17 page no : 54" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 250.\n", + "R_a = 0.15 \n", + "R_sh = 167.67 \t\t\t#armature and shunt field resistance\n", + "N_0 = 1280. \t\t\t#speed at no load\n", + "\n", + "#full load\n", + "I_L1 = 67. \t\t\t#current drawn on full load\n", + "I_sh = V / R_sh \t\t\t#as shunt motor\n", + "I_a1 = I_L1- I_sh\n", + "E_b1 = V - I_a1*R_a\n", + "\n", + "#on no load\n", + "I_L0 = 6.5\n", + "I_a0 = I_L0 - I_sh\n", + "E_b0 = V - I_a0*R_a\n", + "\n", + "# Calculations and Results\n", + "#part(i) USING SPEED EQUATION\n", + "#N (prop.) E_b/phi (prop.)E_b \t\t\t#as phi is constant\n", + "N_1 = N_0 * (E_b1 / E_b0)\n", + "print 'i)Full load speed = %.3f r.p.m'%(N_1)\n", + "\n", + "#part(ii)\n", + "speed_regulation = 100* ((N_0-N_1)/N_1)\n", + "#N_1 is full load speed and N_0 = No load speed \n", + "print 'ii)Speed regulation = %.2f percent '%(speed_regulation )\n", + "\n", + "#part(iii)\n", + "shaft_output_FL = E_b1*I_a1 - E_b0*I_a0 \t\t\t#full load power developed - stray losses\n", + "hp_rating = shaft_output_FL /746\n", + "print 'iii)HP rating of machine = %.2f h.p'%(hp_rating)\n", + "\n", + "#part(iv)\n", + "power_input = V*I_L1\n", + "eta = 100*(shaft_output_FL/power_input) \t\t\t#full load efficiency\n", + "print 'iv)Full load efficiency = %.2f percent'%(eta)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Full load speed = 1233.396 r.p.m\n", + "ii)Speed regulation = 3.78 percent \n", + "iii)HP rating of machine = 19.42 h.p\n", + "iv)Full load efficiency = 86.48 percent\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.18 page no : 55" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 200.\n", + "R_a = 0.5\n", + "R_se = 0.2\n", + "R_x = 0.2 \t\t\t#armature and series field resistance; extra resistance\n", + "I_a1 = 20.\n", + "I_1 = I_a1 \n", + "I_se1 = I_a1\n", + "I_a2 = 20.\n", + "I_2 = I_a2\n", + "I_se2 = I_2 *(R_x/(R_se+R_x))\n", + "\n", + "# Calculations\n", + "E_b1 = V -I_a1*R_a - I_a1*R_se\n", + "E_b2 = V -I_a2*R_a - I_se2*R_se\n", + "\n", + "phi2_by_phi1 = 70./100\n", + "N_1 = 1000\n", + "N_2 = N_1*(E_b2/E_b1) /phi2_by_phi1 \t\t\t#N (prop.) E_b/phi\n", + "\n", + "# Results\n", + "print 'Required speed is %.2f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required speed is 1443.93 r.p.m\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.19 page no : 57" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 110.\n", + "P = 4.\n", + "R_a = 0.1\n", + "R = 0.01 \t\t\t#A resistance of 0.01 ohms\n", + "R_se = R+R\n", + "\n", + "# Calculations\n", + "#case(i)\n", + "I_1 = 50.\n", + "I_a1 = I_1\n", + "N_1 = 700.\n", + "E_b1 = V -I_a1*(R_a + R_se)\n", + "\n", + "#T (prop) phi*I_a from torque equation (1)\n", + "\n", + "#phi_1 (prop.) I_a1 (2)\n", + "#case(ii) when I_a2 gets divided to half\n", + "#phi_2 (prop.) I_a2/2 (3)\n", + "\n", + "#combining (1)(2)(3) and T1 = T2\n", + "I_a2 = math.sqrt(2*I_a1**2)\n", + "R_se_eqvt = (R*R)/(R+R) \t\t\t#Equavalent of parallel combination\n", + "E_b2 = V - I_a2*R_a - I_a2* R_se_eqvt\n", + "\n", + "#using speed equation N (prop.) E_b / phi and using (2) and (3)\n", + "N_2 = N_1 *( E_b2/E_b1) *(I_a1/(I_a2/2))\n", + "\n", + "# Results\n", + "print 'Speed after reconnection = %.3f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed after reconnection = 976.389 r.p.m\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.20 page no : 58" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "P = 4.\n", + "I_a1 = 50.\n", + "N_1 = 2000.\n", + "V = 230.\n", + "\n", + "\n", + "# Calculations and Results\n", + "#phi_1 is proportioanl to total ampere-turns produced by field coils\n", + "#phi_1 (prop.) I_a1*P*n (prop.) 200*n (1)\n", + "\n", + "#After reconnection ,phi_2 proportional to ampere turns divided as follows\n", + "#phi_2 (prop.) [I_a2/2*2*n + I_a2/2*2*n] (prop.) 2*n*I_a2 (2)\n", + "\n", + "# Dividing (1) and (2) ,(phi_1/phi_2) = 100 / I_a2 (3)\n", + "\n", + "#T (prop.) phi*I_a AND T (prop.) N**2 (4)(5)\n", + "#therefore N**2 (prop.) phi*I_a (6)\n", + "\n", + "#N (prop.) E_b/phi (prop.) 1/phi ..\n", + "#Because drops across windings can be neglected , E_b1 = E_b2\n", + "#therefore N (prop.) 1/phi (7)\n", + "\n", + "#using (7) and (6) phi**3 (prop.) 1/I_a (8)\n", + "\n", + "#combining (3) and (8)\n", + "I_a2 = (50.*100**3)**(1./4) \t\t\t#new armature current\n", + "print 'New armature current = %.3f A'%(I_a2)\n", + "#combining (6) and (7) N**3 (prop.) I_a1\n", + "N_2 = N_1 *(I_a2/I_a1)**(1./3)\n", + "print 'New motor speed = %.3f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New armature current = 84.090 A\n", + "New motor speed = 2378.414 r.p.m\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + " Example 2.22 page no : 61" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 200.\n", + "I_a1 = 30.\n", + "R_t = 1.5 \t\t\t#R_a + R_se\n", + "E_b1 = V - I_a1*R_t\n", + "N2_by_N1 = (60./100)\n", + "\n", + "# Calculations\n", + "#T (prop.) I_a**2 and T (prop.) N_3....therefore I_a**2 (prop.) N**3\n", + "I_a2 = I_a1*math.sqrt(N2_by_N1**3)\n", + "\n", + "#N (prop.) E_b/I_a\n", + "N2_by_N1\n", + "E_b2 = E_b1 *(I_a2/I_a1)*N2_by_N1\n", + "R_x = (V- E_b2)/I_a2 - R_t \t\t\t#because E_b2 = V - I_a2*(R_x+R_t)\n", + "\n", + "# Results\n", + "print 'Additional resistance to be added in series with motor circuit = %.3f ohms'%(R_x)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Additional resistance to be added in series with motor circuit = 9.744 ohms\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.23 page no : 63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import *\n", + "\n", + "# Variables\n", + "V = 250.\n", + "R_a = 0.4 \n", + "R_sh = 100. \t\t\t#armature and shunt field resistance\n", + "I_sh1 = V / R_sh\n", + "P_out_FL = 10 * 735.5\n", + "eta = 85./100 \t\t\t#efficiency\n", + "P_in = P_out_FL/eta\n", + "I_L1 = P_in /V\n", + "I_a1 = I_L1 - I_sh1\n", + "\n", + "# T (prop.) phi*I_a (prop.) I_sh*I_a because phi (prop.) I_sh\n", + "#Bu torque is constant.. \n", + "Ia2_Ish2 = I_a1*I_sh1\n", + "E_b1 = V - I_a1*R_a\n", + "\n", + "#N (prop.) E_b/I_sh\n", + "#put E_b2 = V - I_a2*R_a and solving further for I_sh2 we get ,I_sh2**2 - 1.8824 I_sh2 +0.2417 = 0\n", + "p = array([1, -1.8824, 0.2417])\n", + "ans = roots(p) \n", + "I_sh2 = ans[0]\n", + "#root 1 was considered because its always easier to attain root(1) because less resistacne is needeed\n", + "#R_x in series with field\n", + "R_x = (V/I_sh2) -R_sh \t\t\t#because I_sh2 = V/(R_sh + R_x)\n", + "print 'Extra resistance to be added = %.2f ohms'%(R_x)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Extra resistance to be added = 43.37 ohms\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.24 page no : 64" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "R_t = 1. \t\t\t#R_t = R_se + R_a\n", + "V_1 = 230.\n", + "N_1 = 300.\n", + "N_2 = 375.\n", + "I_1 = 15.\n", + "I_a1 = I_1\n", + "\n", + "# Calculations\n", + "#T (prop.) I_a**2 and T (prop.) N_2....therefore I_a**2 (prop.) N**2\n", + "I_a2 = I_a1 *(N_2/N_1)\n", + "E_b1 = V_1 - I_a1*(R_t)\n", + "\n", + "#N (prop.) E_b/I_a\n", + "E_b2 = E_b1*(I_a2/I_a1)*(N_2/N_1)\n", + "V_2 = E_b2 + I_a2* (R_t) \t\t\t#because E_b2 = V_2 - I_a2*(R_a+R_se)\n", + "\n", + "# Results\n", + "print 'Voltage supply needed = %.4f V'%(V_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage supply needed = 354.6875 V\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.25 page no : 66" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "I_L1 = 30.\n", + "V = 230.\n", + "R_sh = 230.\n", + "R_a = 1.\n", + "I_sh = V / R_sh\n", + "I_a1 = I_L1 - I_sh\n", + "E_b1 = V - I_a1*R_a\n", + "\n", + "# Calculations\n", + "#T (prop.) phi*I_a (prop.) I_a as phi is constant\n", + "#and torque is constant\n", + "I_a2 = I_a1\n", + "N2_by_N1 = 1./2\n", + "#N (prop.) E_b/phi (prop.) E_b\n", + "E_b2 = E_b1 *(N2_by_N1)\n", + "R_x = (V- E_b2)/I_a2 - R_a \t\t\t#Because E_b2 = V - I_a2*(R_a + R_x)\n", + "\n", + "# Results\n", + "print 'resistance to be inserted in series = %.4f ohms '%(R_x)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "resistance to be inserted in series = 3.4655 ohms \n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.26 page no : 67" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "\n", + "# Variables\n", + "T_1 = 40. \t\t\t#initial torque\n", + "#phi_1 is initial flux\n", + "#phi_2 is new flux\n", + "#T_2 is new torque\n", + "#I_a1 is initial current\n", + "#I_a2 is new current\n", + "phi2_by_phi1 = 1- (30./100) \t\t\t#decrease by 30 percent\n", + "Ia2_by_Ia1 = 1+(15./100) \t\t\t#increase by 15 percent\n", + "\n", + "# Calculations\n", + "#T (prop.)phi*I_a\n", + "T_2 = T_1*(phi2_by_phi1)*(Ia2_by_Ia1)\n", + "\n", + "# Results\n", + "print 'New torque is %.1f N-m'%(T_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New torque is 32.2 N-m\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.27 page no : 67" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "\n", + "# Variables\n", + "V = 230.\n", + "N_1 = 1000.\n", + "N_2 = 950.\n", + "R_a = 0.5\n", + "R_sh = 230. \t\t\t#armature and shunt field resistance\n", + "I_L1 = 10.\n", + "\n", + "# Calculations\n", + "I_sh = V/R_sh\n", + "I_a1 = I_L1 - I_sh\n", + "\n", + "#T (prop.) phi*I_a (prop.) I_a with phi constant and T is constant due to full-load\n", + "I_a2 = I_a1\n", + "\n", + "E_b1 = V - I_a1*R_a\n", + "E_b2 = E_b1*(N_2/N_1) \t\t\t#N (prop.) E_b /phi (prop.) E_b as phi is constant\n", + "\n", + "R_x = (V-E_b2)/I_a2 -R_a \n", + "\n", + "# Results\n", + "print 'resistance to be inserted in series with armature = %.4f ohms'%(R_x)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "resistance to be inserted in series with armature = 1.2528 ohms\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.28 page no : 68" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 250.\n", + "N_0 = 1000.\n", + "I_0 = 5.\n", + "R_a = 0.2\n", + "R_sh = 250. \t\t\t#armature and shunt field resistance\n", + "I_L = 50. \t\t\t#on no load\n", + "I_sh = V / R_sh\n", + "I_a0 = I_0 - I_sh\n", + "I_a = I_L - I_sh\n", + "E_b0 = V- I_a0*R_a\n", + "E_b1 = V- I_a *R_a\n", + "\n", + "# Calculations\n", + "phi1_by_phi0 = 1-(3./100) \t\t\t#weakens by 3 percent\n", + "#N (prop.) E_b/phi\n", + "N_1 = N_0 *(E_b1/E_b0) /phi1_by_phi0\n", + "\n", + "# Results\n", + "print 'Speed when loaded and drawing 50A current is %.3f r.p.m'%(N_1)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed when loaded and drawing 50A current is 993.695 r.p.m\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.29 page no : 69" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 230.\n", + "I_a0 = 3.3\n", + "R_a = 0.3\n", + "R_sh = 160. \t\t\t#armature and shunt field resistance \n", + "I_L1 = 40.\n", + "N_0 = 1000.\n", + "E_b0 = V - I_a0*R_a\n", + "I_sh = V/ R_sh\n", + "I_a1 = I_L1 - I_sh\n", + "E_b1 = V - I_a1*R_a\n", + "phi1_by_phi0 = 1- (4./100) \t\t\t#weakening by 4 percent \n", + "\n", + "# Calculations and Results\n", + "N_1 = N_0 *(E_b1/E_b0)/(phi1_by_phi0) \t\t\t#because N (prop.) E_b/phi\n", + "print 'Full load speed is %.4f rpm'%(N_1)\n", + "T_0 = E_b0*I_a0/(2*math.pi*N_0/60)\n", + "T_1 = T_0*(I_a1/I_a0)*phi1_by_phi0 \t\t\t# because T (prop.) phi*I_a\n", + "print 'Full load developed torque is %.4f N-m'%(T_1)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full load speed is 993.5485 rpm\n", + "Full load developed torque is 80.9585 N-m\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.30 page no : 70" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 220.\n", + "I_L = 52.\n", + "N_1 = 750.\n", + "N_2 = 600.\n", + "R_a = 0.2\n", + "R_sh = 110. \t\t\t#armature and shunt field resistance\n", + "\n", + "# Calculations and Results\n", + "I_sh = V/ R_sh\n", + "I_a1 = I_L - I_sh\n", + "I_a2 = I_a1\t\t\t#T (prop.) I_a and T is constant\n", + "E_b1 = V - I_a1*R_a\n", + "\n", + "#N (prop.) E_b/phi (prop.) E_b\n", + "E_b2 = E_b1*(N_2/N_1)\n", + "R_x = (V- E_b2)/I_a2 -R_a \t\t\t#Because E_b2 = V - I_a2*(R_a+R_x)\n", + "print 'resistance to be connected in series = %.2f ohms'%(R_x)\n", + "\n", + "#After R_x gets connected in series with armature and 110 ohms in series with field winding\n", + "N_1 = 600.\n", + "I_sh2 = V /(R_sh+110)\n", + "I_a1 = 50.\n", + "I_sh1 = 2.\n", + "I_sh2 = 1.\n", + "#T (prop.) I_a*I_sh and T doesn't vary\n", + "I_a2 = I_a1*(I_sh1/I_sh2)\n", + "E_b1 = V - I_a1*(R_a+R_x)\n", + "E_b2 = V - I_a2*(R_a+R_x)\n", + "N_2 = N_1*(E_b2/E_b1)*(I_sh1/I_sh2) \t\t\t#Because N (prop.) E_b/I_sh\n", + "print 'New speed = %.3f rpm'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "resistance to be connected in series = 0.84 ohms\n", + "New speed = 828.571 rpm\n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.31 page no : 72" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 230.\n", + "R_a = 0.15\n", + "R_sh = 250. \t\t\t#armature and shunt field resistance\n", + "I_a1 = 50.\n", + "I_a2 = 80.\n", + "N_1 = 800.\n", + "N_2 = 1000.\n", + "I_sh1 = V / R_sh\n", + "\n", + "# Calculations\n", + "E_b1 = V - I_a1*R_a\n", + "E_b2 = V - I_a2*R_a\n", + "\n", + "I_sh2 = I_sh1*(E_b2/E_b1)*(N_1/N_2) \t\t\t#Because N (prop.) E_b/ I_sh\n", + "R_x = (V/I_sh2 ) - R_sh \t\t\t#because I_sh2 = V /(R_x+ R_sh)\n", + "\n", + "# Results\n", + "print 'resistance to be added is R_x = %.0f ohms'%(R_x)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "resistance to be added is R_x = 69 ohms\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.32 page no : 74" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 230.\n", + "R_a = 0.5\n", + "N_1 = 800.\n", + "N_2 = 600.\n", + "I_a2 = 20. \n", + "I_a1 = I_a2\n", + "E_b1 = V - I_a1*R_a\n", + "\n", + "# Calculations\n", + "#N (prop.) E_b/phi (prop.) E_b as phi is constant\n", + "E_b2 = E_b1 *(N_2/N_1)\n", + "#additional resistance required\n", + "R_x = (V -E_b2)/I_a2 - R_a \t\t\t#because E_b2 = V - I_a2*(R_a+R_x)\n", + "\n", + "# Results\n", + "print 'Additional resistance required = %.2f ohms '%(R_x)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Additional resistance required = 2.75 ohms \n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.33 page no : 74" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 220.\n", + "R_a = 0.5\n", + "R_x = 5. \t\t\t#armature resistacne and extra resistance\n", + "I_1 = 15.\n", + "I_se1 = I_1\n", + "I_se2 = I_se1 \n", + "I_2 = I_se2\n", + "N_1 = 800.\n", + "\n", + "# Calculations\n", + "E_b1 = V - I_1*R_a\n", + "E_b2 = V - I_2*(R_a+R_x)\n", + "\n", + "N_2 = N_1*(E_b2/E_b1)*(I_se1/I_se2) \t\t\t#because N (prop.) E_b/I_se\n", + "\n", + "# Results\n", + "print 'New speed of rotor = %.3f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New speed of rotor = 517.647 r.p.m\n" + ] + } + ], + "prompt_number": 36 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.34 page no : 75" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 250.\n", + "I_a1 = 20.\n", + "R_a = 0.5\n", + "N_1 = 1000.\n", + "N_2 = 500.\n", + "\n", + "# Calculations and Results\n", + "#T (prop.) I_a and T_1 = T_2\n", + "I_a2 = I_a1\n", + "E_b1 = V - I_a1*R_a\n", + "\n", + "#N (prop.) E_b\n", + "E_b2 = E_b1 *(N_2/N_1)\n", + "R_x = (V-E_b2)/I_a2 - R_a \t\t\t#because E_b2 = V - I_a2*(R_a+R_x)\n", + "print 'Additional resistance = %.0f ohms'%(R_x)\n", + "T3_by_T2 = 0.5 \t\t\t#torque is halved\n", + "I_a3 = I_a2 *(T3_by_T2) \t\t\t#new armature current\n", + "E_b3 = V - I_a3*(R_x + R_a)\n", + "N_3 = E_b3*N_2 / E_b2 \t\t\t#N (prop.) E_b\n", + "print 'New speed = %.3f rpm'%(N_3)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Additional resistance = 6 ohms\n", + "New speed = 770.833 rpm\n" + ] + } + ], + "prompt_number": 37 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.35 page no : 76" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "P_out = 100*735.5\n", + "V = 500.\n", + "P = 4.\n", + "A = 2.\t\t\t# due to wave winding\n", + "Z = 492. \t\t\t#no of conductors\n", + "phi = 50.*10**-3 \t\t\t#flux per pole\n", + "eta = 92./100 \t\t\t#efficiency\n", + "P_in = P_out/eta\n", + "R_a = 0.1 \n", + "R_sh = 250. \t\t\t#amature and shunt field resistance\n", + "\n", + "# Calculations\n", + "I_L = P_in/V\n", + "I_sh = V/ R_sh\n", + "I_a = I_L - I_sh\n", + "E_b = V - I_a*R_a\n", + "N = E_b*60*A/(phi*P*Z) \t\t\t#because E_b = phi*P*N*Z/(60*A)\n", + "\n", + "T_sh = P_out/(2*math.pi*N/60) \t\t\t#Useful torque\n", + "\n", + "# Results\n", + "print 'i)Speed at full load = %.4f rpm'%(N)\n", + "print 'ii)Useful torque = %.2f N-m'%(T_sh)\n", + "print 'Answer mismatches due to improper approximation'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Speed at full load = 590.5011 rpm\n", + "ii)Useful torque = 1189.41 N-m\n", + "Answer mismatches due to improper approximation\n" + ] + } + ], + "prompt_number": 38 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.36 page no : 77" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from numpy import *\n", + "import math \n", + "\n", + "# Variables\n", + "N_1 = 1000.\n", + "I_1 = 50.\n", + "I_a1 = I_1\n", + "V = 250.\n", + "R_x = 4.4\n", + "R_t = 0.6 \t\t\t#R_t = R_a+R_se\n", + "E_b1 = V - I_a1*(R_t)\n", + "\n", + "# Calculations\n", + "#T (prop.)I_a**2 T (prop.) N**2 .... hence N (prop.) I_a\n", + "#N (prop.) E_b /I_a \n", + "#combining both E_b (prop.) I_a**2\n", + "#using E_b2 = V - I_a2*(R_a + R_se + R_x) and solving for I_a2 we get 0.088 I_a2**2 +5 I_a2 -250 = 0\n", + "p = [0.088 ,5, -250] \n", + "ans = roots(p)\n", + "I_a2 = ans[1] \t\t\t#root(1) is ignored as it is -ve\n", + "E_b2 = V - I_a2*(R_t + R_x) \n", + "N_2 = N_1*(E_b2/E_b1)*(I_a1/I_a2)\n", + "\n", + "# Results\n", + "print 'Motor speed = %.2f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Motor speed = 639.79 r.p.m\n" + ] + } + ], + "prompt_number": 39 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.37 page no : 78" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from numpy import *\n", + "import math \n", + "\n", + "# Variables\n", + "V = 250.\n", + "I_a1 = 20.\n", + "R_sh = 250.\n", + "R_a = 0.5 \t\t\t#shunt field and armature resistance\n", + "I_sh1 = V / R_sh\n", + "E_b1 = V - I_a1*R_a\n", + "\n", + "#T (prop.) phi*I_a (prop.) I_sh*I_a\n", + "#math.since T_1 = T_2\n", + "I_sh2_I_a2 = I_sh1*I_a1 \n", + "I_sh2_I_a2 = I_sh1*I_a1 \t\t\t# = 20\n", + "\n", + "# Calculations\n", + "#N (prop.) E_b/I_sh\n", + "#E_b1 = V - I_a1*R_a\n", + "#Solving further for I_a2 we get I_a2**2 -500 I_a2 + 12800\n", + "p = [1, -500, 12800]\n", + "ans = roots(p)\n", + "I_a2 = ans[1] \t\t\t#higher root is neglected\n", + "I_sh2 = I_sh2_I_a2 / I_a2\n", + "R_x = (V / I_sh2) - R_sh \t\t\t#resistance to be inserted in shunt field\n", + "\n", + "# Results\n", + "print 'resistance to be inserted = %.4f ohms '%(R_x)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "resistance to be inserted = 88.3129 ohms \n" + ] + } + ], + "prompt_number": 40 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.38 page no : 79" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "\n", + "# Variables\n", + "V = 250.\n", + "N_1 = 1000.\n", + "I_L1 = 25.\n", + "R_a = 0.2\n", + "R_sh = 250. \t\t\t#armature and shunt field resistance\n", + "V_brush = 1. \t\t\t#voltage drop due to brushes\n", + "\n", + "# Calculations and Results\n", + "I_sh1 = V/R_sh\n", + "I_a1 = I_L1 - I_sh1\n", + "E_b1 = V- I_a1*R_a - 2 *V_brush\n", + "\n", + "#when loaded\n", + "I_L2 = 50.\n", + "I_sh2 = I_sh1 \t\t\t#as flux weakensby armature reaction shunt field current remains same \n", + "I_a2 = I_L2 - I_sh2\n", + "E_b2 = V- I_a2*R_a - 2 *V_brush\n", + "\n", + "phi2_by_phi1 = 1- (3./100) \t\t\t#weakens by 3 percent\n", + "N_2 = N_1*(E_b2/E_b1)/ phi2_by_phi1 \t\t\t#N (prop.) E_b/phi\n", + "print 'New speed = %.3f rpm'%(N_2)\n", + "T_1 = E_b1*I_a1/(2*math.pi*N_1/60)\n", + "T_2 = E_b2*I_a2/(2*math.pi*N_2/60)\n", + "print 'Torque before field weakening = %.4f N-m'%(T_1)\n", + "print 'Torque after field weakening = %.4f N-m'%(T_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New speed = 1009.733 rpm\n", + "Torque before field weakening = 55.7373 N-m\n", + "Torque after field weakening = 110.3831 N-m\n" + ] + } + ], + "prompt_number": 41 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.39 page no : 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "\n", + "# Variables\n", + "V = 220.\n", + "R_a = 0.5\n", + "R_x = 1. \t\t\t#armature resistance and extra resistance\n", + "N_FL = 500. \t\t\t#full load speed in r.p.m\n", + "I_a_FL = 30.\n", + "\n", + "# Calculations and Results\n", + "#part(i) Full load \n", + "E_b_FL = V- I_a_FL * R_a\n", + "#T (prop.) I_a... T is constant\n", + "I_a_dash_FL = I_a_FL \n", + "E_b_dash_FL = V- I_a_dash_FL * (R_a+R_x)\n", + "#N (prop.) E_b/phi (prop.) E_b\n", + "N_dash_FL = N_FL*(E_b_dash_FL/E_b_FL)\n", + "print 'i)Speed at full load torque = %.4f r.p.m'%(N_dash_FL)\n", + "\n", + "#part(ii)\n", + "T2_by_T1 = 2\n", + "I_a_dash_FL = I_a_FL *(T2_by_T1)\n", + "E_b_dash_FL = V- I_a_dash_FL * (R_a+R_x)\n", + "N_dash_FL = N_FL*(E_b_dash_FL/E_b_FL)\n", + "print 'ii)Speed at double full load torque = %.3f r.p.m'%(N_dash_FL)\n", + "\n", + "#part(iii) ...stalling\n", + "E_b = 0 \t\t\t#as speed is zero in case of stalling torque\n", + "I_a_stall = (V-E_b)/(R_a+R_x)\n", + "T_FL = E_b_FL * I_a_FL/(2*math.pi*N_FL/60)\n", + "T_stall = T_FL *(I_a_stall/ I_a_FL)\n", + "print 'iii)Stalling torque = %.3f Nm'%(T_stall)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Speed at full load torque = 426.8293 r.p.m\n", + "ii)Speed at double full load torque = 317.073 r.p.m\n", + "iii)Stalling torque = 574.231 Nm\n" + ] + } + ], + "prompt_number": 42 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.40 page no : 81" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 230.\n", + "I_a1 = 30.\n", + "R_a = 0.4\n", + "R_x = 1.1\t\t\t#armature resistance and extra resistance\n", + "N_1 = 500.\n", + "\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "E_b1 = V - I_a1*R_a\n", + "I_a2 = I_a1 \t\t\t#I_a is constant as T , phi are constant\n", + "E_b2 = V - I_a2*(R_a+R_x)\n", + "N_2 = N_1 *(E_b2/E_b1) \t\t\t#Because N (prop.) E_b/phi (prop.) E_b\n", + "print 'i)Speed at full load torque = %.3f r.p.m'%(N_2)\n", + "\n", + "#part(ii)\n", + "T2_by_T1 = 1.5\n", + "I_a2 = I_a1 * T2_by_T1\n", + "E_b2 = V - I_a2*(R_a+R_x)\n", + "N_2 = N_1 *(E_b2/E_b1) \t\t\t#Because N (prop.) E_b/phi (prop.) E_b\n", + "print 'ii)Speed at 1.5 times full load torque = %.3f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Speed at full load torque = 424.312 r.p.m\n", + "ii)Speed at 1.5 times full load torque = 372.706 r.p.m\n" + ] + } + ], + "prompt_number": 43 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/DC_Machines_and_Synchronous_Machines/ch3.ipynb b/DC_Machines_and_Synchronous_Machines/ch3.ipynb new file mode 100755 index 00000000..6f59c07f --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/ch3.ipynb @@ -0,0 +1,1912 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:851db29572c4b7f5287b09f53c6bb9c3406b6b6577d3bab318bf198d21eaaa81" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 3 : Testing of D C Machines" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.1 page no : 5" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 6.\n", + "V = 500.\n", + "A = 2. \t\t\t#because of wave wound armature\n", + "Z = 1200. \t\t\t#number of armature conductors\n", + "phi = 20.*10**-3 \t\t\t#useful flux per pole\n", + "Ra = 0.5 \n", + "Rsh = 250. \t\t\t#armature and field resistance\n", + "Il = 20. \t\t\t#current drawn from supply\n", + "mechanical_losses = 900.\n", + "Ish = V/Rsh\n", + "Ia = Il-Ish\n", + "Eb = V-Ia*Ra \t\t\t#because V = Eb+Ia*Ra\n", + "N = Eb*60*A/(phi*Pole*Z) \t\t\t#Eb = phi*Pole*N*Z/(60*A)\n", + "\n", + "# Calculations\n", + "P_m = Eb*Ia \t\t\t#Electrical equivalent of mechanical power\n", + "omega = 2*math.pi*N/60\n", + "Tg = P_m/omega\n", + "\n", + "P_out = P_m-mechanical_losses\n", + "T_sh = P_out/omega \t\t\t#Useful torque\n", + "P_in = V*Il\n", + "percentage_efficiency = 100*P_out/P_in\n", + "\n", + "# Results\n", + "print 'Speed developed is %.3f r.p.m \\\n", + "\\nTorque developed is %.2f N-m \\\n", + "\\nUseful torque is %.2f N-m \\\n", + "\\nEfficiency is %.2f percent'%(N,Tg,T_sh,percentage_efficiency)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed developed is 409.167 r.p.m \n", + "Torque developed is 206.26 N-m \n", + "Useful torque is 185.26 N-m \n", + "Efficiency is 79.38 percent\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.2 page no : 10" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "#no load\n", + "I_noload = 2.5 \t\t\t#No load current\n", + "V = 440.\n", + "R_a = 1.2\n", + "R_sh = 550.\t\t\t#resistance of armature and shunt field windings\n", + "no_load_input = V*I_noload\n", + "\n", + "# Calculations\n", + "I_sh = V/R_sh\n", + "I_a_noload = I_noload-I_sh\n", + "no_load_armature_copper = (I_a_noload**2)*R_a\n", + "constant_losses = no_load_input-no_load_armature_copper\n", + "\n", + "#full load\n", + "I_fullload = 32\n", + "I_a_fullload = I_fullload-I_sh\n", + "full_load_armature_coppe = (I_a_fullload**2)*R_a\n", + "total_losses = full_load_armature_coppe+constant_losses\n", + "full_load_motor_input = V*I_fullload\n", + "full_load_motor_output = full_load_motor_input-total_losses\n", + "efficiency_at_full_load = full_load_motor_output*100/full_load_motor_input\n", + "\n", + "# Results\n", + "print 'Full load motor output is %.2f W \\\n", + "\\nEfficiency of motor at full-load is %.2f percent'%(full_load_motor_output,efficiency_at_full_load)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full load motor output is 11815.34 W \n", + "Efficiency of motor at full-load is 83.92 percent\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.3 page no : 11" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import *\n", + "\n", + "# Variables\n", + "#no load\n", + "I = 14. \t\t\t#input current\n", + "V = 230.\n", + "power_output_FL = 45.*10**3\n", + "power_input = V*I\n", + "I_sh = 2.55 \t\t\t#field current\n", + "R_a = 0.032 \t\t\t#armature resistance\n", + "I_a = I-I_sh\n", + "cu_loss_NL = I_a**2*R_a \t\t\t#no load copper loss\n", + "brush_loss = 2*I_a\n", + "constant_loss = power_input - cu_loss_NL - brush_loss\n", + "\n", + "# Calculations and Results\n", + "#full load\n", + "#I = I_a+ 2.55\n", + "#Motor input = Motor output + constant loss + brush loss + cu loss\n", + "# solving for I_a I_a**2 - 7125 I_a + 1487700.3 = 0\n", + "p = [1, -7125, 1487700.3]\n", + "ans = roots(p)\n", + "I_a = ans[1] \t\t\t#ignoring second root as its too large\n", + "I = I_a+I_sh\n", + "print 'Full load current is %.2f A'%(I)\n", + "power_input = V*I\n", + "eta = 100*(power_output_FL/power_input)\n", + "print 'Efficiency at full load is %.2f percent'%(eta)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full load current is 217.86 A\n", + "Efficiency at full load is 89.81 percent\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.4 page no : 14" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "\n", + "# Variables\n", + "W1 = 9.1 \t\t\t#Tension on tight side\n", + "W2 = 0.8 \t\t\t#Tension on slack side\n", + "I = 10. \t\t\t#Total_current\n", + "V = 110. \t\t\t#Supply voltage\n", + "R = 7.5/100 \t\t\t#Radius of p-ulley in metres\n", + "N = 1320. \t\t\t#speed in r.p.m\n", + "\n", + "# Calculations\n", + "T_sh = (W1-W2)*9.81*R \t\t\t#9.81 is the accelration due to gravity\n", + "omega = (2*math.pi*N/60)\n", + "P_out = T_sh*omega\n", + "P_in = V*I\n", + "\n", + "efficiency = 100*P_out/P_in\n", + "\n", + "# Results\n", + "print 'Full load Efficiency is %.2f percent'%(efficiency)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full load Efficiency is 76.74 percent\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.5 page no : 17" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 250.\n", + "I_av = 10.\n", + "V_av = (240.+220)/2 \t\t\t#average voltage across load\n", + "W_dash = V_av*I_av \t\t\t#Power absorbed\n", + "t1 = 25.\n", + "t2 = 6.\n", + "R_sh = 200.\n", + "R_a = 0.3\t\t\t#resistance of field winding and armature \n", + "\n", + "# Calculations\n", + "W = W_dash*t2/(t1-t2) \t\t\t#Stray Losses\n", + "I_l = 25 \t\t\t#Input current\n", + "I_sh = V/R_sh \t\t\t#current through field winding\n", + "\n", + "I_a = I_l-I_sh \t\t\t#Armature current\n", + "arm_cu_loss = R_a*I_a**2 \t\t\t#Armature copper losses\n", + "sh_cu_loss = R_sh*I_sh**2 \t\t\t# Shunt copper loss\n", + "\n", + "Total_losses = arm_cu_loss + sh_cu_loss + W\n", + "Motor_input = V*I_l\n", + "Output = Motor_input- Total_losses\n", + "efficiency = Output*100/Motor_input\n", + "\n", + "# Results\n", + "print 'Efficiency as motor at 25 A and 250 V is %.2f percent'%(efficiency)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency as motor at 25 A and 250 V is 80.67 percent\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.6 page no : 22" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "\n", + "# Variables\n", + "I_a = 37.\n", + "I_sh = 0.85\t\t\t#armature and field current for motor\n", + "V = 230.\n", + "R_a = 0.33 \t\t\t#armature resistance\n", + "\n", + "I_a_g = 30.\n", + "I_sh_g = 0.8\t\t\t#armature and field current for generator\n", + "\n", + "\n", + "# Calculations and Results\n", + "#for motor\n", + "arm_cu_loss = I_a**2* R_a \t\t\t#armature copper losses\n", + "field_cu_loss = V*I_sh \t\t\t#field copper loss\n", + "total_cu_loss = field_cu_loss + arm_cu_loss \t\t\t#total copper loss \n", + "\n", + "#for generator\n", + "arm_cu_loss_g = I_a_g**2* R_a \t\t\t#armature copper losses\n", + "field_cu_loss_g = V*I_sh_g \t\t\t#field copper loss\n", + "total_cu_loss_g = field_cu_loss_g + arm_cu_loss_g \t\t\t#total copper loss\n", + "\n", + "#for motor-generator set\n", + "total_cu_loss_set = total_cu_loss_g + total_cu_loss\n", + "P_supply = V*(I_a - I_a_g + I_sh+ I_sh_g ) \t\t\t#power taken from supply\n", + "stray_loss = P_supply - (total_cu_loss_g + total_cu_loss) \n", + "stray_loss_each = stray_loss/2 \t\t\t#stray loss for each machine\n", + "\n", + "#efficiency of motor\n", + "motor_input = V*(I_a+I_sh)\n", + "motor_output = motor_input - (stray_loss_each + total_cu_loss)\n", + "eta_m = 100* motor_output/motor_input \t\t\t#efficiency of motor\n", + "print 'Efficiency of motor is %.2f percent '%(eta_m)\n", + "#efficiency of generator\n", + "generator_input = motor_output \t\t\t#output of motor is input of generator\n", + "generator_output = generator_input - (stray_loss_each + total_cu_loss_g)\n", + "eta_g = 100* generator_output/generator_input \t\t\t#efficiency of generator\n", + "print 'Efficiency of generator is %.2f percent '%(eta_g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of motor is 87.62 percent \n", + "Efficiency of generator is 88.05 percent \n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.7 page no : 25" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "I_1 = 400. \t\t\t#motor input current\n", + "V = 200. \t\t\t#voltage across armature\n", + "I_2 = 32. \t\t\t#load current\n", + "V_2 = 160. \t\t\t#voltage across generator\n", + "V_f = 15. \t\t\t#voltage drop across field windings\n", + "total_input = (V+V_f)*I_1 \n", + "Output = V_2*I_2\n", + "total_losses = total_input-Output \t\t\t#total losses in 2 machines\n", + "\n", + "# Calculations and Results\n", + "R_se = V_f/I_1 \t\t\t#series field resistance\n", + "R_a = 0.4 \t\t\t# armature field resistance\n", + "\n", + "total_cu_loss = (R_a + 2*R_se) * I_1**2 + I_2**2*R_a \t\t\t#total copper loss\n", + "stray_losses = total_losses - total_cu_loss\n", + "stray_losses_each = stray_losses /2 \t\t\t#stray losses for each machine\n", + "\n", + "#for motor\n", + "motor_input = V*I_1\n", + "arm_cu_loss = (R_a + R_se)*I_1*I_1 \t\t\t#armature copper loss\n", + "total_losses_motor = arm_cu_loss + stray_losses_each \n", + "motor_output = motor_input- total_losses_motor\n", + "eta_m = 100*motor_output/motor_input \t\t\t#efficiency of motor\n", + "print 'Efficiency of motor is %.2f percent '%(eta_m)\n", + "#for generator\n", + "arm_cu_loss_gen = R_a*I_2**2 \t\t\t#armature copper loss\n", + "series_field_cu_loss = V_f*I_1 \t\t\t#series field copper loss\n", + "total_losses_gen = arm_cu_loss_gen + series_field_cu_loss + stray_losses_each \n", + "generator_input = total_losses_gen+ Output\n", + "eta_gen = 100*Output/generator_input \t\t\t#efficiency of generator\n", + "print 'Efficiency of generator is %.2f percent'%(eta_gen)\n", + "\n", + "\n", + "#Note : 'Answer dont match because Output-of-generator is taken as 5220 for calculation while its should have been 5120'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of motor is 9.71 percent \n", + "Efficiency of generator is 37.20 percent\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.8 page no : 27" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "V = 500.\n", + "Io = 5. \t\t\t#no load current\n", + "R_a = 0.5\n", + "R_sh = 250.\t\t\t#resistance of armature and field circuits\n", + "I = 100. \t\t\t#current at unknown efficiency\n", + "\n", + "# Calculations\n", + "P_in_NL = V*Io \t\t\t#no load input\n", + "I_sh = V/R_sh\n", + "\n", + "Iao = Io-I_sh\n", + "arm_cu_loss_no_load = R_a*Iao**2 \t\t\t#No load armature copper loss\n", + "constant_losses = P_in_NL- arm_cu_loss_no_load\n", + "\n", + "I_a = I-I_sh\n", + "arm_cu_loss = R_a*I_a**2 \t\t\t#New armature copper loss\n", + "\n", + "Total_loss = arm_cu_loss + constant_losses\n", + "P_in = V*I\n", + "efficiency = (P_in-Total_loss)*100/P_in \t\t\t#required efficiency\n", + "\n", + "\n", + "# Results\n", + "print 'Efficiency is %.3f percent when motor takes %.0f A current'%(efficiency,I)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency is 85.405 percent when motor takes 100 A current\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.9 page no : 28" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 500. \n", + "I_NL = 5. \t\t\t#no load current \n", + "P_in_NL = V* I_NL \t\t\t#no load input\n", + "R_a = 0.22\n", + "R_sh = 250. \t\t\t#resistance of armature and shunt field winding\n", + "I_sh = V/R_sh\n", + "I_a_NL = I_NL-I_sh \t\t\t#armature current no load\n", + "arm_cu_loss_NL = R_a*I_a_NL**2 \t\t\t#No-load armature copper loss\n", + "constant_loss = P_in_NL - arm_cu_loss_NL\n", + "\n", + "# Calculations and Results\n", + "#at 100 A current\n", + "I = 100.\n", + "I_a = I - I_sh\n", + "arm_cu_loss = R_a*I_a**2 \t\t\t#armature copper loss\n", + "total_loss = arm_cu_loss + constant_loss \n", + "motor_input = V*I\n", + "motor_output = motor_input- total_loss\n", + "eta_m = 100*motor_output/motor_input \t\t\t#motor efficiency\n", + "print 'Parta)Efficiency of motor when it takes 100 A current and loaded is %.2f percent'%(eta_m)\n", + "\n", + "#part(b)\n", + "E_b_NL = V - I_a_NL*R_a \t\t\t#back emf at no load\n", + "\n", + "E_b = V- I_a*R_a \t\t\t#back EMF at 100 A current\n", + "#Since E_b is proportional to N and using componendo dividendo\n", + "delta_speed = 100*((E_b_NL-E_b)/E_b)\n", + "print 'Partb)Percentage speed in speed is %.3f percent'%(delta_speed)\n", + "\n", + "print 'Note that the following were assumptions made'\n", + "print 'i) Due to heating %( resistance of shunt field winding will be increased which will reduce the shunt field current.This will decrease the flux which is neglected'\n", + "print 'ii) Though the motor speed is changing from no load to given load , the mechanical losses are assumed to be cosnstant'\n", + "print 'iiiThe effect of armature reaction aon main pole flux and its effect on iron loss is neglected'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Parta)Efficiency of motor when it takes 100 A current and loaded is 90.78 percent\n", + "Partb)Percentage speed in speed is 4.368 percent\n", + "Note that the following were assumptions made\n", + "i) Due to heating %( resistance of shunt field winding will be increased which will reduce the shunt field current.This will decrease the flux which is neglected\n", + "ii) Though the motor speed is changing from no load to given load , the mechanical losses are assumed to be cosnstant\n", + "iiiThe effect of armature reaction aon main pole flux and its effect on iron loss is neglected\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.10 page no : 30" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "motor_output_FL = 15000. \t\t\t#full load motor output\n", + "V = 250.\n", + "R_sh = 100.\n", + "\n", + "# Calculations\n", + "#at 80 % of full load\n", + "motor_output_FL_dash = (80./100)*motor_output_FL \t\t\t#80 percent of full load output\n", + "eta = 90./100 \t\t\t#efficiency\n", + "motor_input = motor_output_FL_dash/eta\n", + "total_losses = motor_input - motor_output_FL_dash \t\t\t#at 80 % of full load\n", + "#at maximum efficiency variable losses = constant losses\n", + "constant_losses = total_losses/2\n", + "variable_losses = constant_losses\n", + "I = motor_input/V \t\t\t#line current at 80% load\n", + "I_sh = V/ R_sh\n", + "I_a = I- I_sh\n", + "#math.since armature copper loss = R_a*I_a**2 \n", + "R_a = variable_losses/I_a**2\n", + "E_b1 = V-I_a*R_a \t\t\t#motor back EMF at 80% of full load\n", + "N_1 = 750. \t\t\t# corresponding speed is given as 750 rpm\n", + "\n", + "#When motor current is 80 A\n", + "I = 80.\n", + "I_a = I-I_sh\n", + "arm_cu_losses = R_a*I_a**2 \t\t\t#armature copper loss\n", + "total_losses = arm_cu_losses + constant_losses\n", + "motor_input = V*I\n", + "motor_output = motor_input- total_losses\n", + "eta = 100*motor_output/motor_input \t\t\t#efficiency of motor\n", + "E_b2 = V-I_a*R_a \t\t\t#motor back EMF at 80% of full load\n", + "N_2 = N_1*(E_b2/E_b1) \t\t\t#because E_b is proportional to N\n", + "\n", + "# Results\n", + "print 'Efficiency of motor is %.2f percent when motor draws 80A current'%(eta)\n", + "print 'and Speed is %.2f r.p.m'%(N_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of motor is 88.92 percent when motor draws 80A current\n", + "and Speed is 728.22 r.p.m\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.11 page no : 32" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 250.\n", + "R_sh = 166.67\n", + "R_a = 0.15 \t \t\t#resistance of shunt field winding and armature\n", + "N_0 = 1280. \t\t\t#in rpm\n", + "I_L1 = 67. \t\t\t#current drawn on full load\n", + "I_sh = V/ R_sh\n", + "I_a1 = I_L1 - I_sh\n", + "E_b1 = V-I_a1*R_a\n", + "\n", + "#on no load\n", + "I_L0 = 6.5\n", + "I_a0 = I_L0 - I_sh\n", + "E_b0 = V-I_a0*R_a\n", + "\n", + "# Calculations and Results\n", + "#part (i)\n", + "#using speed equation N is proportional to E_b\n", + "N_1 = N_0*(E_b1/E_b0)\n", + "print 'i)Full load speed is %.3f r.p.m'%(N_1)\n", + "\n", + "#part (ii)\n", + "speed_regulation = 100*((N_0-N_1)/N_1)\n", + "print 'ii)Speed regulation is %.2f percent '%(speed_regulation)\n", + "\n", + "#part (iii)\n", + "stray_losses = E_b0*I_a0 \t\t\t#mechanical power developed on no load\n", + "power_developed_FL = E_b1*I_a1 \n", + "shaft_output_FL = power_developed_FL - stray_losses \n", + "hp_rating = shaft_output_FL/746 \t\t\t#in horse power\n", + "print 'iii)H.P rating of the machine Is %.2f H.P'%(hp_rating)\n", + "\n", + "#part (iv)\n", + "power_input = V*I_L1\n", + "eta = 100*(shaft_output_FL/power_input) \t\t\t#efficiency at full load\n", + "print 'iv)Efficiency at full load is %.2f percent'%(eta)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Full load speed is 1233.396 r.p.m\n", + "ii)Speed regulation is 3.78 percent \n", + "iii)H.P rating of the machine Is 19.42 H.P\n", + "iv)Efficiency at full load is 86.48 percent\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.12 page no : 33" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 200.\n", + "R_sh = 240.\n", + "R_a = 0.1 \t\t\t#resistance of shunt field winding and armature\n", + "rotational_loss = 236.\n", + "I_L_FL = 9.8 \t\t\t#full load line current\n", + "N = 1450.\n", + "I_sh = V/R_sh\n", + "I_a_FL = I_L_FL - I_sh\n", + "E_b = V- I_a_FL * R_a\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "gross_mech_P_dev = E_b*I_a_FL \t\t\t#gross mechanical power developed\n", + "mech_P_dev = gross_mech_P_dev - rotational_loss \t\t\t#mechanical power developed\n", + "print 'i)Gross mechanical power developed is %.2f W'%(gross_mech_P_dev )\n", + "print ' Mechanical power developed is %.2f W'%(mech_P_dev )\n", + "\n", + "#part(ii)\n", + "P_out = mech_P_dev \n", + "print 'ii)The power output is %.2f W'%(P_out)\n", + "\n", + "#part(iii)\n", + "T_sh = P_out*60/(2*math.pi*N)\n", + "T_L = T_sh\n", + "print 'iii)Load torque is %.2f N-m'%(T_L)\n", + "\n", + "#part(iv)\n", + "P_in = V*I_L_FL\n", + "eta = 100*P_out/P_in\n", + "print 'iv)Efficiency at full load is %.2f percent'%(eta)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Gross mechanical power developed is 1785.29 W\n", + " Mechanical power developed is 1549.29 W\n", + "ii)The power output is 1549.29 W\n", + "iii)Load torque is 10.20 N-m\n", + "iv)Efficiency at full load is 79.05 percent\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.13 page no : 34" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 240.\n", + "P_out = 25*735.5 \t\t\t#output power in watts\n", + "R_a = 0.14\n", + "R_sh = 80. \t \t\t#resistance of armature and shunt field winding\n", + "brush_drop = 1. \t\t\t#voltage drop across brush\n", + "I_L_FL = 95. \t\t \t#input current at full load \n", + "I_sh = V/R_sh\n", + "I_a_FL = I_L_FL - I_sh \t\t\t#armature current at full load\n", + "\n", + "# Calculations and Results\n", + "arm_cu_loss_FL = R_a*I_a_FL**2 \t\t\t#full load armature copper loss\n", + "field_cu_loss = R_sh*I_sh**2 \t\t\t#field copper loss\n", + "print 'i)Armature and field copper losses are %.2f W and %.0f W respectively'%(arm_cu_loss_FL,field_cu_loss)\n", + "brush_cu_loss = 2*brush_drop*I_a_FL \t\t\t#brush contact copper loss\n", + "print 'ii)Brush contact copper loss is %.0f W'%(brush_cu_loss)\n", + "E_b = V-I_a_FL*R_a - 2*brush_drop \t\t\t#back emf\n", + "gross_mech_P_dev = E_b*I_a_FL \t\t\t#gross mechanical power developed\n", + "IFW_losses = gross_mech_P_dev - P_out \t\t\t#iron friction and windage losses\n", + "print 'iii)Core plus mechanical losses = %.1f W'%(IFW_losses+field_cu_loss+arm_cu_loss_FL)\n", + "eta = 100*(P_out/(P_out + IFW_losses+ brush_cu_loss+field_cu_loss+arm_cu_loss_FL ))\n", + "print 'iv)Efficiency is %.2f percent'%(eta)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Armature and field copper losses are 1184.96 W and 720 W respectively\n", + "ii)Brush contact copper loss is 184 W\n", + "iii)Core plus mechanical losses = 4228.5 W\n", + "iv)Efficiency is 80.65 percent\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.14 page no : 36" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "I = 5. \t\t\t#no load current\n", + "V = 500.\n", + "R_sh = 250.\n", + "R_a = 0.5 \t\t\t#resistance of shunt field winding and armature\n", + "motor_input_NL = V*I\n", + "I_sh = V/R_sh\n", + "I_a = I-I_sh\n", + "arm_cu_loss_NL = R_a*I_a**2 \t\t\t#no load armature copper loss\n", + "constant_loss = motor_input_NL - arm_cu_loss_NL\n", + "I_FL = 50.\n", + "I_a_FL = I_FL - I_sh \t\t\t#currents at full load\n", + "arm_cu_loss_FL = R_a*I_a_FL**2 \t\t\t#full load armature copper loss\n", + "\n", + "# Calculations and Results\n", + "total_loss = constant_loss + arm_cu_loss_FL \n", + "motor_input = V*I_FL\n", + "motor_output_FL = motor_input - total_loss\n", + "print 'Required output power is %.3f kW'%(motor_output_FL/1000)\n", + "eta = 100*(motor_output_FL/motor_input) \t\t\t#full load efficiency\n", + "print 'Full load efficiency of motor with 50A current is %.2f percent '%(eta)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required output power is 21.352 kW\n", + "Full load efficiency of motor with 50A current is 85.41 percent \n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.15 page no : 36" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 250.\n", + "R_sh = 275.\n", + "R_a = 0.8 \t\t\t#resistance of shunt field and amature\n", + "I_L0 = 3.91 \t\t\t#load current\n", + "I_sh = V/R_sh\n", + "I_a0 = I_L0 - I_sh\n", + "constant_losses = V*I_L0 -R_a*(I_a0)**2\n", + "\n", + "# Calculations and Results\n", + "#as a generator\n", + "P_out = 10*10**3\n", + "I_L = P_out/V\n", + "I_a = I_L + I_sh \n", + "field_cu_loss = R_sh*(I_sh)**2 \t\t\t#field copper loss\n", + "arm_cu_loss = R_a*(I_a)**2 \t\t\t#armature copper loss \n", + "eta_gen = 100 *(P_out/(P_out+constant_losses + field_cu_loss+ arm_cu_loss)) \t\t\t#efficiency as generator\n", + "print 'Efficiency as a generator = %.2f percent'%(eta_gen)\n", + "\n", + "#as a motor\n", + "P_in = 10*10**3 \t\t\t#at V = 250 \n", + "I_L = P_in/V\n", + "I_a = I_L - I_sh\n", + "field_cu_loss = R_sh*(I_sh)**2 \t\t\t#field copper loss\n", + "arm_cu_loss = R_a*(I_a)**2 \t\t\t#armature copper loss \n", + "eta_m = 100 *((P_in-(constant_losses + field_cu_loss+ arm_cu_loss))/(P_in)) \t\t\t#efficiency as motor\n", + "print 'Efficiency as a motor = %.2f percent'%(eta_m)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency as a generator = 79.77 percent\n", + "Efficiency as a motor = 75.80 percent\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.16 page no : 38" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "I = 4. \t\t\t#no load current in amperes\n", + "V = 500.\n", + "motor_input_no_load = I*V \t\t\t#no load motor input\n", + "R_a = 0.5\n", + "R_sh = 250.\t\t\t#resistance of armature and shunt field resistnace\n", + "I_sh = V/R_sh\n", + "\n", + "I_a = I-I_sh\n", + "arm_cu_loss_noload = R_a*I_a**2 \t\t\t#No-load armature copper losses\n", + "constant_loss = motor_input_no_load - arm_cu_loss_noload\n", + "I_FL = 40.\n", + "I_aFL = I_FL- I_a \t\t\t#full load currents\n", + "arm_cu_loss_fulload = R_a*I_aFL**2 \t\t\t#Full-load armature copper losses\n", + "Total_loss = arm_cu_loss_fulload + constant_loss\n", + "\n", + "# Calculations and Results\n", + "motor_input = V*I_FL\n", + "motor_output_fullload = motor_input - Total_loss\n", + "print 'Output power at full-load is %.0f W'%(motor_output_fullload) \n", + "efficiency = motor_output_fullload*100/motor_input \t\t\t#motor efficiency\n", + "print 'Efficiency at full-load is %.1f percent'%(efficiency)\n", + "\n", + "E_bNL = V-I_a*R_a\n", + "E_bFL = V-I_FL*R_a\n", + "\n", + "#E_b = N*phi\n", + "#E_bNL/E_bFL = N_NL/N_FL\n", + "#applying rules of componendo and dividendo\n", + "#change_in _speed = (N_NL - N_FL)/N_FL = (E_bNL - E_bFL)/E_bFl\n", + "\n", + "change_in_speed = 100*(E_bNL - E_bFL)/E_bFL\n", + "print 'percentage change in speed from no load to full load is %.3f percent'%(change_in_speed)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Output power at full-load is 17280 W\n", + "Efficiency at full-load is 86.4 percent\n", + "percentage change in speed from no load to full load is 3.958 percent\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.17 page no : 39" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 500.\n", + "R_a = 0.22\n", + "R_sh = 250.\t\t\t#armature resistance and shunt field resistance\n", + "I = 5. \t\t\t#no load current\n", + "motor_input_NL = V*I \t\t\t#no load motor input\n", + "I_sh = V/R_sh\n", + "I_a_NL = I- I_sh \t\t\t#no load armature current\n", + "arm_cu_loss_NL = R_a*I_a_NL**2 \t\t\t#no load armature copper loss\n", + "constant_loss = motor_input_NL - arm_cu_loss_NL \n", + "\n", + "# Calculations and Results\n", + "#When motor draws 100 A current \n", + "I = 100\n", + "I_a = I - I_sh\n", + "arm_cu_loss = R_a* I_a**2 \t\t\t#armature copper loss\n", + "total_losses = arm_cu_loss + constant_loss\n", + "motor_input = V*I\n", + "motor_output = motor_input -total_losses \n", + "eta_m = 100*(motor_output/motor_input) \t\t\t#motor efficiency\n", + "print 'i)Efficiency of motor at 100 A current is %.2f percent '%(eta_m)\n", + "\n", + "#part(b)\n", + "E_b_NL = V- I_a_NL*R_a \t\t\t#back emf at no load\n", + "E_b = V- I_a*R_a \t\t\t#back emf at 100 A \n", + "#E_b is proportional to N.. and using componendo dividendo\n", + "speed_change = 100*((E_b_NL - E_b)/E_b)\n", + "print 'ii)Percentage change in speed = %.3f percent'%(speed_change)\n", + "\n", + "\n", + "print 'Note that the following were assumptions made'\n", + "print 'i) Due to heating resistance of shunt field winding will be increased which will reduce the shunt field current.This will decrease the flux which is neglected'\n", + "print 'ii) Though the motor speed is changing from no load to given load %( the mechanical losses are assumed to be cosnstant'\n", + "print 'iiiThe effect of armature reaction aon main pole flux and its effect on iron loss is neglected'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Efficiency of motor at 100 A current is 90.78 percent \n", + "ii)Percentage change in speed = 4.368 percent\n", + "Note that the following were assumptions made\n", + "i) Due to heating resistance of shunt field winding will be increased which will reduce the shunt field current.This will decrease the flux which is neglected\n", + "ii) Though the motor speed is changing from no load to given load %( the mechanical losses are assumed to be cosnstant\n", + "iiiThe effect of armature reaction aon main pole flux and its effect on iron loss is neglected\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.18 page no : 41" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 200.\n", + "I_L = 40.\n", + "\n", + "R_sh = 200.\n", + "R_a = 0.2 \t\t\t#shunt field winding and armature resistance\n", + "\n", + "# Calculations and Results\n", + "#case(a) : As a generator\n", + "P_out_g = V*I_L \t\t\t#output poewr as generator\n", + "I_sh = V/R_sh\n", + "I_a = I_L + I_sh\n", + "E = V + I_a*R_a\n", + "P_a_g = E*I_a \t\t\t#power developed in armature\n", + "P_cu_g = R_a*I_a**2 + R_sh*I_sh**2 \t\t\t#copper loss as genrator\n", + "print 'i)Output as generator is %.f kW'%(P_out_g/1000)\n", + "\n", + "#case(b) : As a motor\n", + "P_in_m = V*I_L \t\t\t#input power as motor\n", + "I_sh = V/R_sh\n", + "I_a = I_L - I_sh\n", + "E_b = V - I_a*R_a\n", + "P_a_m = E_b*I_a \t\t\t#power developed in armature\n", + "P_cu_m = R_a*I_a**2 + R_sh*I_sh**2\t\t\t#copper loss as motor\n", + "print 'ii)Input as motor is %.0f kW'%( P_in_m/1000)\n", + "print 'iii)Power developed in Armature:%.4f kW for generator%.4f kW for motor'%(P_a_g/1000,P_a_m/1000)\n", + "print 'iv)Copper losses:%.1f W for generator%.1f W for motor'%(P_cu_g,P_cu_m)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Output as generator is 8 kW\n", + "ii)Input as motor is 8 kW\n", + "iii)Power developed in Armature:8.5362 kW for generator7.4958 kW for motor\n", + "iv)Copper losses:536.2 W for generator504.2 W for motor\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.19 page no : 42" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 219.\n", + "I = 10.\n", + "dN = 1030. - 970 \t\t\t#given\n", + "t_1 = 36. \t\t\t#time with no excitation\n", + "t_2 = 9.\t\t\t# time with full excitation and armature supporting an extra load of 10 A at 219 V\n", + "t_3 = 15. \t\t\t#time with full exciation\n", + "W_dash = V*I \t\t\t#additioanl loss when armature is suddenly connected to loads\n", + "W_s = W_dash *(t_2/(t_3-t_2)) \t\t\t#total stray losses\n", + "N = 1000. \t\t\t#speed in rpm\n", + "\n", + "# Calculations\n", + "#using W_s = (2*pi/60)**2 * I *N *dN / t_3 where W_s is stray losses\n", + "I = W_s*(t_3/dN)*(30/math.pi)**2/N \t\t\t#moment of inertia\n", + "W_m = W_s*(t_3/t_1) \t\t\t#mechanical losses\n", + "iron_losses = W_s - W_m\n", + "\n", + "# Results\n", + "print 'i)The moment of inertia of armature is %.2f kg-m**2'%(I)\n", + "print 'ii)Iron loss = %.2f W'%(iron_losses)\n", + "print 'iii)Mechanical losses at 1000 rpm mean speed is %.2f W'%(W_m)\n", + "\n", + "print 'Noteworthy points:1)When armature is slowing down and there is no excitation,then kinetic energy is used to overcome mechanical losses only.Iron losses are absent as excitation is absent2)When excitation is given%( kinetic energy is used to overcome both mechanical as well as iron losses.Total called stray losses.3)If moment of inertia is in kg-m**2,then loss of energy is in watts'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)The moment of inertia of armature is 74.89 kg-m**2\n", + "ii)Iron loss = 1916.25 W\n", + "iii)Mechanical losses at 1000 rpm mean speed is 1368.75 W\n", + "Noteworthy points:1)When armature is slowing down and there is no excitation,then kinetic energy is used to overcome mechanical losses only.Iron losses are absent as excitation is absent2)When excitation is given%( kinetic energy is used to overcome both mechanical as well as iron losses.Total called stray losses.3)If moment of inertia is in kg-m**2,then loss of energy is in watts\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.20 page no : 43" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 225.\n", + "I = 10.\n", + "dN = 1030. - 970 \t\t\t#given\n", + "t_1 = 40. \t\t\t#time with no excitation\n", + "t_2 = 9.\t\t\t# time with full excitation and armature supporting an extra load of 10 A at 219 V\n", + "t_3 = 20. \t\t\t#time with full exciation\n", + "\n", + "# Calculations\n", + "W_dash = V*I \t\t\t#additional loss\n", + "W_s = W_dash *(t_2/(t_3-t_2)) \t\t\t#total stray losses\n", + "N = 1000\t\t\t#Speed in rpm\n", + "\t\t\t#using W_s = (2*pi/60)**2 * I *N *dN / t_3 where W_s is stray losses\n", + "I = W_s*(t_3/dN)*(30/math.pi)**2/N \t\t\t#moment of inertia\n", + "W_m = W_s*(t_3/t_1) \t\t\t#mechanical losses\n", + "iron_losses = W_s - W_m\n", + "\n", + "# Results\n", + "print 'i)The moment of inertia of armature is %.2f kg-m**2'%(I)\n", + "print 'ii)Iron loss = %.2f W'%(iron_losses)\n", + "print 'iii)Mechanical losses at 1000 rpm mean speed is %.2f W'%(W_m)\n", + "\n", + "print 'Noteworthy points:1)When there is no excitation and armature is slowed down , its K.E. is used to overcome mechanical mechanical losses only math.since there will be no iron loss as there is no flux.2)When there is excitation provided then K.E. is used to supply mechanical as well as iron losses together called stray losses '\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)The moment of inertia of armature is 55.96 kg-m**2\n", + "ii)Iron loss = 920.45 W\n", + "iii)Mechanical losses at 1000 rpm mean speed is 920.45 W\n", + "Noteworthy points:1)When there is no excitation and armature is slowed down , its K.E. is used to overcome mechanical mechanical losses only math.since there will be no iron loss as there is no flux.2)When there is excitation provided then K.E. is used to supply mechanical as well as iron losses together called stray losses \n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.21 page no : 44" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_avg = (220.+190)/2 \t\t\t#average voltage across load\n", + "I_avg = 12.\n", + "R_a = 0.5\n", + "R_sh = 250.\n", + "W_dash = V_avg*I_avg \t\t\t#power absorbed \n", + "t_1 = 30.\n", + "t_2 = 5.\n", + "W = W_dash*(t_2/(t_1-t_2))\n", + "V = 250.\n", + "I = 22. \t\t\t#input current\n", + "\n", + "# Calculations\n", + "I_sh = V/R_sh\n", + "I_a = I - I_sh\n", + "arm_cu_loss = R_a*I_a**2 \t\t\t#armature copper loss\n", + "shunt_field_cu_loss = V*I_sh \t\t\t#shunt field copper loss\n", + "total_losses = shunt_field_cu_loss + arm_cu_loss + W\n", + "\n", + "machine_input = V*I\n", + "machine_output = machine_input - total_losses \n", + "eta_m = 100*(machine_output /machine_input ) \t\t\t#efficiency when running as motor\n", + "\n", + "# Results\n", + "print 'Efficiency of machine when opeating as motor taking current of 22A on 250V supply is %.1f percent'%(eta_m)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of machine when opeating as motor taking current of 22A on 250V supply is 82.5 percent\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.22 page no : 45" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "I_avg = 10.\n", + "V_avg = (220.+190)/2 \t\t\t#average voltage across load\n", + "W_dash = V_avg*I_avg \t\t\t#power absorbed\n", + "t_1 = 30.\n", + "t_2 = 20.\n", + "\n", + "# Calculations\n", + "W = W_dash * (t_2/(t_1-t_2)) \t\t\t#stray losses\n", + "\n", + "# Results\n", + "print 'Stray losses of motor is %.1f kW'%(W/1000)\n", + "print 'Answers mismatch because V_average is 205 volts but it is taken as 220 volts in Power absorbed calculation'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Stray losses of motor is 4.1 kW\n", + "Answers mismatch because V_average is 205 volts but it is taken as 220 volts in Power absorbed calculation\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.23 page no : 46" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "I_a_g = 330.\n", + "I_a_m = 380.\n", + "R_a = 0.02 \t\t\t#armature resistance\n", + "V = 250.\n", + "I = 50.\n", + "\n", + "\n", + "arm_cu_loss_g = R_a*I_a_g**2\t\t\t#armature copper loss for generator\n", + "arm_cu_loss_m = R_a*I_a_m**2\t\t\t#armature copper loss for motor\n", + "power_drawn = V*I\n", + "stray_losses = power_drawn - (arm_cu_loss_m + arm_cu_loss_g)\n", + "stray_losses_each = stray_losses/2 \t\t\t#stray losses for each machine\n", + "\n", + "\n", + "# Calculations and Results\n", + "#for motor\n", + "I_sh_m = 4.2 \t\t\t#Shunt current in case of motor\n", + "field_cu_loss_m = V*I_sh_m \t\t\t#field copper loss in case of motor\n", + "total_loss = field_cu_loss_m + stray_losses_each + arm_cu_loss_m\n", + "motor_input = V*(I_a_m+I_sh_m) \n", + "motor_output = motor_input - total_loss\n", + "eta_m = 100*(motor_output/motor_input)\t\t\t#motor efficiency \n", + "print 'Efficiency of motor is %.4f percent'%(eta_m)\n", + "\n", + "#for generator\n", + "I_sh_g = 5 \t\t\t#Shunt current in case of generator\n", + "field_cu_loss_g = V*I_sh_g \t\t\t#field copper loss in case of generator\n", + "total_loss = field_cu_loss_g + stray_losses_each + arm_cu_loss_g\n", + "generator_output = V*I_a_g\n", + "generator_input = generator_output + total_loss\n", + "eta_g = 100*(generator_output/generator_input)\t\t\t#generator efficiency \n", + "print 'Efficiency of generator is %.4f percent'%(eta_g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of motor is 92.0302 percent\n", + "Efficiency of generator is 92.0297 percent\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.24 page no : 47" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "R_a = 0.02 \t\t\t#armature resistance\n", + "V = 250. \t\t\t#line voltage\n", + "I = 50. \t\t\t#current taken from supply \n", + "\n", + "# Calculations and Results\n", + "#for generator\n", + "I_a_g = 330.\n", + "I_sh_g = 5. \t\t\t#armature current and current through shunt field \n", + "arm_cu_loss_g = R_a*I_a_g**2\t\t\t#armature copper loss for generator\n", + "field_cu_loss_g = V*I_sh_g \t\t\t#field copper loss for generator\n", + "\n", + "#for motor\n", + "I_a_m = 380\n", + "I_sh_m = 4.2 \t\t\t#armature current and current through shunt field\n", + "arm_cu_loss_m = R_a*I_a_m**2\t\t\t#armature copper loss for motor\n", + "field_cu_loss_m = V*I_sh_m \t\t\t#field copper loss for motor\n", + "power_drawn = V*I\n", + "IFW_losses = power_drawn - (arm_cu_loss_g + arm_cu_loss_m) \t\t\t#Iron friction and windage losses\n", + "IFW_losses_each = IFW_losses /2 \t\t\t# Iron friction and windage losses for each machine\n", + "\n", + "#for generator\n", + "total_loss_g = field_cu_loss_g + arm_cu_loss_g + IFW_losses_each\n", + "generator_output = V*I_a_g\n", + "generator_input = generator_output + total_loss_g \n", + "eta_g = 100*(generator_output/generator_input)\t\t\t#generator efficiency \n", + "print 'Efficiency of generator is %.4f percent'%(eta_g)\n", + "\n", + "#for motor\n", + "total_loss_m = field_cu_loss_m + IFW_losses_each + arm_cu_loss_m\n", + "motor_input = V*(I_a_m+I_sh_m)\n", + "motor_output = motor_input - total_loss_m\n", + "eta_m = 100*(motor_output/motor_input)\t\t\t#motor efficiency \n", + "print 'Efficiency of motor is %.4f percent'%(eta_m)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of generator is 92.0297 percent\n", + "Efficiency of motor is 92.0302 percent\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.25 page no : 49" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 220.\n", + "I = 40.\n", + "I_a_g = 160. \n", + "I_a_m = 200. \t\t\t#armature currents for generator and motor\n", + "I_sh_g = 7. \n", + "I_sh_m = 6. \t\t\t#current through shunt field for generator and motor\n", + "R_a = 0.015 \t\t\t#armature resistance\n", + "arm_cu_loss_g = R_a*I_a_g**2 \t\t\t#armature copper loss for motor\n", + "arm_cu_loss_m = R_a*I_a_m**2 \t\t\t#armature copper loss for motor\n", + "power_drawn = V*I\n", + "IFW_losses = power_drawn - (arm_cu_loss_g + arm_cu_loss_m) \t\t\t#Iron friction and windage losses\n", + "IFW_losses_each = IFW_losses /2 \t\t\t# Iron friction and windage losses for each machine\n", + "\n", + "# Calculations and Results\n", + "#for motor\n", + "field_cu_loss_m = V*I_sh_m \t\t\t#field copper loss for motor\n", + "total_loss_m = field_cu_loss_m + IFW_losses_each + arm_cu_loss_m \t\t\t#total losses in motor\n", + "motor_input = V * I_a_m\n", + "motor_output = motor_input - total_loss_m\n", + "eta_m = 100*(motor_output/motor_input) \t\t\t#motor efficiency\n", + "print 'Efficiency of motor is %.4f percent'%(eta_m)\n", + "\n", + "#for generator\n", + "field_cu_loss_g = V*I_sh_g \t\t\t#field copper loss for generator\n", + "total_loss_g = field_cu_loss_g + arm_cu_loss_g + IFW_losses_each \t\t\t#total losses in generator\n", + "generator_output = V*I_a_g\n", + "generator_input = generator_output + total_loss_g\n", + "eta_g = 100*(generator_output/generator_input)\t\t\t#generator efficiency\n", + "print 'Efficiency of generator is %.4f percent'%(eta_g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of motor is 86.7545 percent\n", + "Efficiency of generator is 85.7867 percent\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.26 page no : 51" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "R_a = 0.2 \t\t\t#armature resistance \n", + "V = 240.\n", + "I = 16.\n", + "I_a_g = 60. \n", + "I_a_m = 71. \t\t\t#armature currents for generator and motor\n", + "I_sh_g = 3. \n", + "I_sh_m = 2. \t\t\t#field current for generator and motor \n", + "\n", + "\n", + "#for generator\n", + "arm_cu_loss_g = R_a*I_a_g**2\t\t\t#armature copper loss for generator\n", + "field_cu_loss_g = V*I_sh_g \t\t\t#field copper loss for generator\n", + "\n", + "#for motor\n", + "arm_cu_loss_m = R_a*I_a_m**2\t\t\t#armature copper loss for motor\n", + "field_cu_loss_m = V*I_sh_m \t\t\t#field copper loss for motor\n", + "power_drawn = V*I\n", + "field_loss_total_g_m = field_cu_loss_m + field_cu_loss_g\n", + "arm_cu_loss_total_g_m = arm_cu_loss_m + arm_cu_loss_g\n", + "IFW_losses = power_drawn - (arm_cu_loss_total_g_m + field_loss_total_g_m) \t\t\t#Iron friction and windage losses\n", + "IFW_losses_each = IFW_losses /2 \t\t\t# Iron friction and windage losses for each machine\n", + "\n", + "# Calculations and Results\n", + "#for generator\n", + "total_loss_g = field_cu_loss_g + arm_cu_loss_g + IFW_losses_each \t\t\t#total loss in generator\n", + "generator_output = V*I_a_g\n", + "generator_input = generator_output + total_loss_g\n", + "eta_g = 100*(generator_output/generator_input)\t\t\t#generator efficiency \n", + "print 'Efficiency of generator is %.4f percent'%(eta_g)\n", + "\n", + "#for motor\n", + "total_loss_m = field_cu_loss_m + IFW_losses_each + arm_cu_loss_m \t\t\t#total loss in motor\n", + "motor_input = V*(I_a_m+I_sh_m)\n", + "motor_output = motor_input - total_loss_m\n", + "eta_m = 100*(motor_output/motor_input)\t\t\t#motor efficiency \n", + "print 'Efficiency of motor is %.4f percent'%(eta_m)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of generator is 88.3658 percent\n", + "Efficiency of motor is 88.9035 percent\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.27 page no : 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "R_a = 0.015\n", + "V = 250. \t\t\t#line voltage\n", + "I = 45. \t\t\t#line current\n", + "I_a_m = 385.\n", + "I_sh_m = 4. \t\t\t#armature and field currents for motor\n", + "I_a_g = 340.\n", + "I_sh_g = 5. \t\t\t#armature and field currents for generator\n", + "arm_cu_loss_m = R_a*I_a_m**2 \t\t\t#armature copper loss for motor\n", + "field_cu_loss_m = V*I_sh_m \t\t\t#field copper loss for motor\n", + "\n", + "arm_cu_loss_g = R_a*I_a_g**2 \t\t\t#armature copper loss for generator\n", + "field_cu_loss_g = V*I_sh_g \t\t\t#field copper loss for motor\n", + "\n", + "total_cu_loss = field_cu_loss_g + arm_cu_loss_g + field_cu_loss_m + arm_cu_loss_m \t\t\t#total copper loss for both machines\n", + "P_aux = V*I \t\t\t#power taken from auxillary supply\n", + "stray_loss = P_aux - total_cu_loss\n", + "stray_loss_each = stray_loss/2 \t\t\t#stray loss for each machine\n", + "\n", + "# Calculations and Results\n", + "total_loss_g = stray_loss_each + arm_cu_loss_g + field_cu_loss_g \t\t\t#total losses in generator\n", + "generator_output = V* I_a_g\n", + "eta_g = 100*(generator_output/(generator_output + total_loss_g))\t\t\t#generator efficiency\n", + "print 'Efficiency of generator is %.4f percent'%(eta_g)\n", + "\n", + "total_loss_m = stray_loss_each + arm_cu_loss_m + field_cu_loss_m\t\t\t#total losses in motor\n", + "motor_input = V*(I_a_m+I_sh_m)\n", + "motor_output = motor_input - total_loss_m\n", + "eta_m = 100*(motor_output/motor_input)\t\t\t#motor efficiency \n", + "print 'Efficiency of motor is %.4f percent'%(eta_m)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of generator is 93.9171 percent\n", + "Efficiency of motor is 94.0929 percent\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.28 page no : 53" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 500.\n", + "P = 1000.*10**3\n", + "I = 30.\n", + "I_a_m = 200. + 30 \n", + "I_a_g = 200. \t\t\t#armature current for motor and generator\n", + "I_sh_m = 1.8\n", + "I_sh_g = 3.5 \t\t\t#field current for motor and generator\n", + "brush_drop = 230.\n", + "R_a = 0.075 \t\t\t#armature resimath.tance\n", + "\n", + "# Calculations\n", + "arm_cu_loss_m = R_a*I_a_m**2 + 2*brush_drop \t\t\t#motor armature copper loss\n", + "field_cu_loss_m = V*I_sh_m \t\t\t# motor field copper loss \n", + "\n", + "arm_cu_loss_g = R_a*I_a_g**2 + 2*brush_drop \t\t\t#generator armature copper loss\n", + "field_cu_loss_g = V*I_sh_g \t\t\t#field copper loss generator\n", + "\n", + "total_cu_loss = field_cu_loss_g + arm_cu_loss_g + field_cu_loss_m + arm_cu_loss_m \t\t\t#total copper loss for both machines\n", + "P_aux = V*I \t\t\t#power taken from auxillary supply\n", + "stray_loss = P_aux - total_cu_loss \n", + "stray_loss_each = stray_loss/2 \t\t\t#stray loss for each machine\n", + "\n", + "total_loss_g = stray_loss_each + arm_cu_loss_g + field_cu_loss_g \t\t\t#total loss in generator\n", + "generator_output = V* I_a_g\n", + "eta_g = 100*(generator_output/(generator_output + total_loss_g))\t\t\t#generator efficiency\n", + "\n", + "# Results\n", + "print 'Efficiency of generator is %.0f percent'%(eta_g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of generator is 93 percent\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.29 page no : 55" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 220.\n", + "I = 10.\n", + "R_a = 0.05 \t \t\t#artmature resistance\n", + "I_a_m = 73. \n", + "I_sh_m = 2. \t \t\t#armature and field current for motor\n", + "I_a_g = 67.5\n", + "I_sh_g = 2.5\t\t \t#armature and field current for generator\n", + "\n", + "arm_cu_loss_m = R_a*I_a_m**2 \t\t\t#motor armature copper loss\n", + "field_cu_loss_m = V*I_sh_m \t\t\t# motor field copper loss \n", + "\n", + "arm_cu_loss_g = R_a*I_a_g**2 \t\t\t#generator armature copper loss\n", + "field_cu_loss_g = V*I_sh_g \t\t\t#field copper loss generator\n", + "\n", + "total_cu_loss = field_cu_loss_g + arm_cu_loss_g + field_cu_loss_m + arm_cu_loss_m \t\t\t#total copper loss for both machines\n", + "power_input = V*I\n", + "stray_loss = power_input - total_cu_loss \n", + "stray_loss_each = stray_loss/2 \t\t\t#stray loss for each machine\n", + "\n", + "# Calculations and Results\n", + "#motor efficiency\n", + "total_loss_m = field_cu_loss_m + stray_loss_each + arm_cu_loss_m \t\t\t#total motor losses\n", + "motor_input = V*(I_a_m + I_sh_m )\n", + "motor_output = motor_input - total_loss_m\n", + "eta_m = 100*(motor_output/motor_input)\t\t\t#motor efficiency \n", + "print 'Efficiency of motor is %.4f percent'%(eta_m)\n", + "\n", + "#generator efficiency\n", + "total_loss_g = field_cu_loss_g + stray_loss_each + arm_cu_loss_g \t\t\t#total generator losses\n", + "generator_output = V*I_a_g\n", + "generator_input = generator_output + total_loss_g\n", + "eta_g = 100*(generator_output/generator_input)\t\t\t#motor efficiency \n", + "print 'Efficiency of generator is %.4f percent'%(eta_g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of motor is 93.5496 percent\n", + "Efficiency of generator is 92.8956 percent\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.30 page no : 57" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 400.\n", + "I = 50.\n", + "I_a_g = 250. \n", + "I_a_m = 300. \t\t\t#armature current for generator and motor\n", + "I_sh_g = 2.5 \n", + "I_sh_m = 2.4 \t\t\t#field current for generator and motor\n", + "R_a = 0.1 \t\t\t#armature resistance\n", + "\n", + "arm_cu_loss_g = R_a*I_a_g**2 \t\t\t#armature copper loss for generator\n", + "arm_cu_loss_m = R_a*I_a_m**2 \t\t\t#armature copper loss for motor\n", + "power_drawn = V*I\n", + "IFW_losses = power_drawn - (arm_cu_loss_g + arm_cu_loss_m) \t\t\t#Iron friction and windage losses\n", + "IFW_losses_each = IFW_losses /2 \t\t\t# Iron friction and windage losses for each machine\n", + "\n", + "# Calculations and Results\n", + "#for motor\n", + "field_cu_loss_m = V*I_sh_m \t\t\t#field copper loss for motor\n", + "total_loss_m = field_cu_loss_m + IFW_losses_each + arm_cu_loss_m\n", + "motor_input = V * I_a_m\n", + "motor_output = motor_input - total_loss_m\n", + "eta_m = 100*(motor_output/motor_input) \t\t\t#motor efficiency\n", + "print 'Efficiency of motor is %.2f percent'%(eta_m)\n", + "\n", + "#for generator\n", + "field_cu_loss_g = V*I_sh_g \t\t\t#field copper loss for generator\n", + "total_loss_g = field_cu_loss_g + arm_cu_loss_g + IFW_losses_each\n", + "generator_output = V*I_a_g\n", + "generator_input = generator_output + total_loss_g\n", + "eta_g = 100*(generator_output/generator_input)\t\t\t#generator efficiency\n", + "print 'Efficiency of generator is %.2f percent'%(eta_g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of motor is 89.72 percent\n", + "Efficiency of generator is 91.22 percent\n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.31 page no : 58" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "I_1 = 56. \t\t\t#motor input current\n", + "V = 590. \t\t\t#voltage across armature\n", + "I_2 = 44. \t\t\t# load current\n", + "V_2 = 400. \t\t\t# voltage across generator\n", + "V_field = 40. \t\t\t#voltage drop across field winding\n", + "R_a = 0.3\n", + "R_se = 0.7142 \t\t\t#armature and series field resistance for each machine\n", + "total_input = (V+V_field)*I_1\n", + "output = V_2*I_2\n", + "total_loss_g_m = total_input - output \t\t\t#total losses of 2 machines\n", + "R_se = V_field/I_1 \t\t\t#series field resistance for both windings\n", + "total_cu_loss = (R_a+ 2*R_se)*I_1**2 + R_a*I_2**2 \t\t\t#total copper loss\n", + "stray_loss = total_loss_g_m - total_cu_loss\n", + "stray_loss_each = stray_loss/2 \t\t\t#stray loss for each machine\n", + "\n", + "# Calculations and Results\n", + "# for motor\n", + "motor_input = V*I_1\n", + "arm_cu_loss_m = (R_a+ R_se)*I_1**2 \t\t\t#armature coper losses of motor\n", + "total_loss_m = arm_cu_loss_m + stray_loss_each\n", + "motor_output = motor_input - total_loss_m\n", + "eta_m = 100*(motor_output/motor_input)\t\t\t#motor efficiency \n", + "print 'Efficiency of motor is %.4f percent'%(eta_m)\n", + "\n", + "# for generator\n", + "arm_cu_loss_g = R_a*I_2**2 \t\t\t#armature coper losses of generator\n", + "series_field_cu_loss_g = V_field*I_1 \t\t\t#series field copper loss\n", + "total_loss_g = arm_cu_loss_g + series_field_cu_loss_g + stray_loss_each\n", + "generator_output = V_2*I_2\n", + "generator_input = generator_output + total_loss_g\n", + "eta_g = 100*(generator_output/generator_input)\t\t\t#generator efficiency \n", + "print 'Efficiency of generator is %.4f percent'%(eta_g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of motor is 72.6998 percent\n", + "Efficiency of generator is 67.0221 percent\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.32 page no : 61" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "I_1 = 56. \t\t\t#motor input current\n", + "V = 590. \t\t\t#voltage across armature\n", + "I_2 = 44. \t\t\t# load current\n", + "V_2 = 400. \t\t\t# voltage across generator\n", + "V_field = 40. \t\t\t#voltage drop across field winding\n", + "R_a = 0.3\n", + "R_se = 0.7142 \t\t\t#armature and series field resismath.tane for each machine\n", + "\n", + "total_input = (V+V_field)*I_1\n", + "output = V_2*I_2\n", + "total_loss_g_m = total_input - output \t\t\t#total losses of 2 machines\n", + "R_se = V_field/I_1 \t\t\t#series field resistance for both windings\n", + "total_cu_loss = (R_a+ 2*R_se)*I_1**2 + R_a*I_2**2 \t\t\t#total copper loss\n", + "stray_loss = total_loss_g_m - total_cu_loss\n", + "stray_loss_each = stray_loss/2 \t\t\t#stray loss for each machine\n", + "\n", + "# Calculations and Results\n", + "# for motor\n", + "motor_input = V*I_1\n", + "arm_cu_loss_m = (R_a+ R_se)*I_1**2 \t\t\t#armature coper losses of motor\n", + "total_loss_m = arm_cu_loss_m + stray_loss_each\n", + "motor_output = motor_input - total_loss_m\n", + "eta_m = 100*(motor_output/motor_input)\t\t\t#motor efficiency \n", + "print 'Efficiency of motor is %.4f percent'%(eta_m)\n", + "\n", + "# for generator\n", + "arm_cu_loss_g = R_a*I_2**2 \t\t\t#armature coper losses of generator\n", + "series_field_cu_loss_g = V_field*I_1 \t\t\t#series field copper loss\n", + "total_loss_g = arm_cu_loss_g + series_field_cu_loss_g + stray_loss_each\n", + "generator_output = V_2*I_2\n", + "generator_input = generator_output + total_loss_g\n", + "eta_g = 100*(generator_output/generator_input)\t\t\t#generator efficiency \n", + "print 'Efficiency of generator is %.4f percent'%(eta_g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of motor is 72.6998 percent\n", + "Efficiency of generator is 67.0221 percent\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/DC_Machines_and_Synchronous_Machines/ch4.ipynb b/DC_Machines_and_Synchronous_Machines/ch4.ipynb new file mode 100755 index 00000000..7e4b687b --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/ch4.ipynb @@ -0,0 +1,1114 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:e5bf1101b5ca7d663f8c7db6ba5353cd5daf17690d3f4785e774f0306b01e83e" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 4 : Synchronous Machines : Alternators" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.1 page no : 16" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variables\n", + "Pole = 4.\n", + "Slots = 24.\n", + "Phase = 3. \t\t\t#number of phases\n", + "\n", + "# Calculations\n", + "n = Slots/Pole \t\t\t#slots per pole\n", + "m = Slots/Pole/Phase \t\t\t#slots per pole per phase\n", + "beeta = 180/n \t\t\t#Slot angle\n", + "\n", + "# results\n", + "print \"Slot angle : %.f degrees\"%beeta" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Slot angle : 30 degrees\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.2 page no : 26" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Slots = 120.\n", + "Pole = 8.\n", + "Phase = 3. \t\t\t#number of phases\n", + "\n", + "# Calculations\n", + "n = Slots/Pole \t\t\t#Slots per Pole\n", + "m = Slots/Pole/Phase \t\t\t#Slots per Pole per Phase\n", + "beeta = 180/n \t\t\t#Slot angle in degree\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t#Distribution Factor\n", + "\n", + "# Results\n", + "print 'Distribution Factor:K_d = %.3f'%(K_d)\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Distribution Factor:K_d = 0.957\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.3 page no : 26" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Slots = 36.\n", + "Pole = 4.\n", + "Phase = 3. \t\t\t#number of phases\n", + "n = Slots/Pole \t\t\t#Slots per pole\n", + "beeta = 180/n \t\t\t#Slot angle in degrees\n", + "\n", + "# Calculations\n", + "#coil is shorted by 1 slot i.e. by beeta degrees to full pitch dismath.tance\n", + "alpha = beeta \t\t\t#angle of short pitch\n", + "K_c = math.cos(math.radians(alpha/2)) \t\t\t#Coil span Factor\n", + "\n", + "# Results\n", + "print 'Coil Span Factor:K_c = %.4f'%(K_c)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Coil Span Factor:K_c = 0.9848\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.4 page no : 26" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "N_s = 250. \t\t\t#Synchronous speed in r.p.m\n", + "f = 50. \t\t\t#Frequency of generated e.m.f in hertz\n", + "Slots = 216.\n", + "phi = 30.*10**-3 \t\t\t#flux per pole in weber\n", + "\n", + "Pole = 120*f/N_s\n", + "n = Slots/Pole \t\t\t#Slots per Pole\n", + "m = n/3 \t\t\t#Slots per Pole per Phase\n", + "beeta = 180/n \t\t\t#Slot angle in degree\n", + "\n", + "# Calculations\n", + "K_d = math.sin(math.radians(m*beeta/2))/(m*math.sin(math.radians(beeta/2))) \t\t\t#distribution factor\n", + "K_c = 1 \t\t\t#Coil Span Factor for full pitch coils = 1\n", + "\n", + "Z = Slots*5 \t\t\t#Z is total no of conductors\n", + "Z_ph = Z/3 \t\t\t#Conductors Per Phase\n", + "T_ph = Z_ph/2 \t\t\t#Turns per phase\n", + "E_ph = 4.44*K_c*K_d*f*phi*T_ph \t\t\t#induced emf\n", + "E_line = E_ph*math.sqrt(3)\n", + "\n", + "# Results\n", + "print 'Induced e.m.f across the Terminals is %.2f V'%(E_line)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced e.m.f across the Terminals is 1992.90 V\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.5 page no : 27" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 16.\n", + "N_s = 375. \t\t\t#synchronous speed in rpm\n", + "Slots = 144.\n", + "E_line = 2.657*10**3 \t\t\t#line value of emf across terminals\n", + "f = Pole*N_s/120 \t\t\t#frequency\n", + "\n", + "# Calculations\n", + "K_c = 1 \t\t\t#assuming full pitch winding Coil span Factor = 1\n", + "n = Slots/Pole \t\t\t#slots per pole\n", + "m = n/3 \t\t\t#slots per pole per phase\n", + "\n", + "beeta = 180/n\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t#Distribution Fcator\n", + "conductors_per_slot = 10\n", + "Z = Slots*conductors_per_slot \t\t\t#total conductors\n", + "\n", + "Z_ph = Z/3 \t\t\t#number of conductors per phase\n", + "T_ph = Z_ph/2 \t\t\t#no of turns per phase\n", + "E_ph = E_line/math.sqrt(3) \t\t\t#phase value of emf across terminals\n", + "\n", + "phi = E_ph/(4.44*K_c*K_d*f*T_ph) \t\t\t#E_ph = 4.44*K_c*K_d*f*phi*T_ph\n", + "\n", + "# Results\n", + "print 'Frequency of Induced e.m.f is %.0fHz \\nFlux per Pole is %.0f mWb'%(f,phi*1000)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Frequency of Induced e.m.f is 50Hz \n", + "Flux per Pole is 30 mWb\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.6 page no : 34" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "d = 0.25 \t\t\t#Diameter in metre\n", + "l = 0.3 \t\t\t#Length in metre\n", + "Pole = 4.\n", + "A1 = math.pi*d*l/Pole \t\t\t#Area of each fundamental pole\n", + "f = 50. \t\t\t#frequency in hertz\n", + "B_m1 = 0.15 \n", + "B_m3 = 0.03\n", + "B_m5 = 0.02 \t\t\t#Amplitude of 1st 3rd and 5th harmonics\n", + "phi_1 = (2/math.pi)*B_m1*A1 \t\t\t#average value of fundamental flux per pole in weber\n", + "\n", + "\n", + "# Calculations and Results\n", + "#PART A\n", + "E_c1 = 1.11*2*f*phi_1 \t\t\t#R.M.S value of fundamental frequency e.m.f generated in math.single conductor\n", + "Coil_span = (13./15)*180 \t\t\t#math.since winding coil span is 13/15 of pole pitch\n", + "alpha = 180-Coil_span\n", + "\n", + "#Pitch factor for 1st 3rd and 5th harmonic\n", + "K_c1 = math.cos(math.radians(alpha/2))\n", + "K_c3 = math.cos(math.radians(3*alpha/2))\n", + "K_c5 = math.cos(math.radians(5*alpha/2))\n", + "\n", + "#using E_cx = E_c1 * (B_mx/B_m1)\n", + "E_c3 = E_c1 * (B_m3/B_m1)\n", + "E_c5 = E_c1 * (B_m5/B_m1)\n", + "\n", + "E_t1 = K_c1 * (2*E_c1) \t\t\t#R.M.S Vaue of fundamental frequency EMF generated in 1 turn (in volts)\n", + "E_t3 = K_c3 * 2*E_c3\n", + "E_t5 = K_c5 * 2*E_c5\n", + "E_t = math.sqrt(E_t1**2 +E_t3**2 +E_t5**2)\n", + "V = 10*E_t \t\t\t#(number of turns per coil )* (Total e.m.f per turn)\n", + "print 'Voltage generated per coil is %.1f V'%(V)\n", + "\n", + "# PART B\n", + "#E_1ph = 4.44*K_c1*K_d1*phi_1*f*T_ph\n", + "T_ph = 200. \t\t\t#T_ph = (60 coils * 10 turns per coil)/3\n", + "\n", + "Total_Conductors = 1200. \t\t\t# 60 coils * 10 turns per coil * 2\n", + "Conductors_per_Slot = 20. \t\t\t#2 conductors per turn * 10 turns per slot\n", + "Slots = Total_Conductors/Conductors_per_Slot\n", + "\n", + "n = Slots/Pole\n", + "m = n/3\n", + "beeta = 180/n \t\t\t#Slot angle in degree\n", + "K_d1 = math.sin(math.radians(m*1*beeta/2)) /(m*math.sin(math.radians(1*beeta/2)))\n", + "K_d3 = math.sin(math.radians(m*3*beeta/2)) /(m*math.sin(math.radians(3*beeta/2)))\n", + "K_d5 = math.sin(math.radians(m*5*beeta/2)) /(m*math.sin(math.radians(5*beeta/2)))\n", + "\n", + "E_1ph = 4.44 * K_c1 * K_d1*phi_1 * f * T_ph\n", + "# using E_xph = E_1ph* (B_mx*K_cx*K_dx)/(B_m1*K_c1*K_d1)\n", + "E_3ph = E_1ph* (B_m3*K_c3*K_d3)/(B_m1*K_c1*K_d1)\n", + "E_5ph = E_1ph* (B_m5*K_c5*K_d5)/(B_m1*K_c1*K_d1)\n", + "E_ph = math.sqrt( E_1ph**2 + E_3ph**2 + E_5ph**2 ) \t\t\t#voltage generated per phase\n", + "print 'Voltage generated per phase is %.f V'%(E_ph)\n", + "\n", + "#PART c\n", + "E_line = math.sqrt(3) * math.sqrt( E_1ph**2 + E_5ph**2 ) \t\t\t#terminal voltage\n", + "print 'Terminal Voltage is %.1f V '%(E_line)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage generated per coil is 12.4 V\n", + "Voltage generated per phase is 235 V\n", + "Terminal Voltage is 404.8 V \n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.7 page no : 38" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Ns = 250. \t\t\t#Synchronous speed in rpm\n", + "f = 50.\n", + "Slots = 288.\n", + "E_line = 6600.\n", + "Pole = 120*f/Ns \n", + "n = Slots/Pole \t\t\t#slots per pole\n", + "m = n/3 \t\t\t#slots per pole per phase\n", + "beeta = 180/n \t\t\t#slot angle\n", + "conductors_per_slot = 32 \t\t\t#16 conductors per coil-side *2 coil-sides per slot\n", + "\n", + "# Calculations\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t#distribution factor\n", + "alpha = 2*beeta\t\t\t# angle of short pitch\n", + "K_c = math.cos(math.radians(alpha/2)) \t\t\t#coil span factor\n", + "Z = Slots*conductors_per_slot \t\t\t#total conductors\n", + "Z_ph = Z/3 \t\t\t#Conductors per phase\n", + "T_ph = Z_ph/2 \t\t\t#turns per phase\n", + "\n", + "E_ph = E_line/math.sqrt(3)\n", + "phi = E_ph/(4.44*K_c*K_d*f*T_ph) \t\t\t#Because E_ph = 4.44 *K_c *K_d *phi *f *T_ph\n", + "\n", + "# Results\n", + "print 'Flux per pole is %.0f mWb '%(phi*1000)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Flux per pole is 12 mWb \n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.8 page no : 40" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Ns = 1500. \t\t\t#synchronous speed in rpm\n", + "Pole = 4.\n", + "Slots = 24.\n", + "conductor_per_slot = 8.\n", + "phi = 0.05 \t\t\t#flux per pole in weber\n", + "f = Pole*Ns/120 \t\t\t#frequenccy\n", + "n = Slots/Pole \t\t\t#slots per pole\n", + "m = n \t\t\t# as number of phases is 1\n", + "beeta = 180/n \t\t\t#slot angle\n", + "\n", + "# Calculations\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t#distribution factor\n", + "\n", + "#Full pitch = n = 6 slots\n", + "#(1/6)th of full pitch = 1slot\n", + "#angle of short pitch = 1 slot angle\n", + "alpha = beeta\n", + "K_c = math.cos(math.radians(alpha/2)) \t\t\t#coil span factor\n", + "\n", + "Z = conductor_per_slot*Slots \t\t\t#total conductors\n", + "Z_ph = Z \t\t\t# as number of phases is 1\n", + "T_ph = Z_ph/2 \t\t\t#turns per phase\n", + "E_ph = 4.44*K_c*K_d* phi *f *T_ph \t\t\t#induced emf\n", + "\n", + "# Results\n", + "print 'Induced e.m.f is %.1f V '%(E_ph)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced e.m.f is 662.8 V \n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.9 page no : 41" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 48.\n", + "n = 9. \t\t\t#slots per pole\n", + "phi = 51.75*10**-3 \t\t\t#flux per pole in weber\n", + "Ns = 125.\n", + "f = Ns*Pole/120 \t\t\t#frequency\n", + "K_c = 1. \t\t\t#due to full pitch winding\n", + "m = n/3 \t\t\t#slots per pole per phase\n", + "beeta = 180/n \t\t\t#slot angle\n", + "\n", + "# Calculations\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t#distribution factor\n", + "conductor_per_slot = 4*2 \t\t\t#Each slot has 2 coil sides and each coil side has 4 conductors\n", + "Slots = n*Pole\n", + "Z = conductor_per_slot*Slots \t\t\t#total number of conductors\n", + "Z_ph = Z/3 \t\t\t#conductors per phase\n", + "T_ph = Z_ph/2 \t\t\t#turns per phase\n", + "E_ph = 4.44 *K_c *K_d *phi *f *T_ph \t\t\t#induced emf\n", + "\n", + "E_line = (math.sqrt(3))*E_ph \t\t\t#due to star connection\n", + "\n", + "# Results\n", + "print 'Induced e.m.f is %.0f kV '%(E_line/1000)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced e.m.f is 11 kV \n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.10 page no : 42" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Slots = 180.\n", + "Pole = 12.\n", + "Ns = 600. \t\t\t#Synchronous speen in rpm\n", + "f = Pole*Ns/120 \t\t\t#frequency\n", + "phi = 0.05 \t\t\t#flux per pole in weber\n", + "\n", + "# Calculations and Results\n", + "#Part(i)\n", + "#Average EMF in a conductor = 2*f*phi\n", + "rms_value_1 = 1.11*2*f*phi \t\t\t#rms value of emf in a conductor\n", + "print 'i)r.m.s value of e.m.f in a conductor is %.2f V '%(rms_value_1)\n", + "\n", + "#part(ii)\n", + "#Average EMF in a turn = 4*f*phi\n", + "rms_value_2 = 1.11*4*f*phi\t\t\t#r.m.s value of e.m.f in a turn\n", + "print 'ii)r.m.s value of e.m.f in a turn is %.2f V '%(rms_value_2)\n", + "\n", + "#part(iii)\n", + "conductors_per_coilside = 10/2 \n", + "rms_value_3 = rms_value_2*conductors_per_coilside \t\t\t#r.m.s value of e.m.f in a coil\n", + "print 'iii)r.m.s value of e.m.f in a coil is %.1f V '%(rms_value_3)\n", + "\n", + "#part(iv)\n", + "conductors_per_slot = 10\n", + "Z = conductors_per_slot * Slots \t\t\t#total number of conductors\n", + "Z_ph = Z/3 \t\t\t#conductors per phase\n", + "T_ph = Z_ph/2 \t\t\t#turns per phase\n", + "n = Slots/Pole \t\t\t#slots per pole\n", + "m = n/3 \t\t\t#slots per pole per phase \n", + "beeta = 180/n \t\t\t#slot angle\n", + "\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2)))\n", + "K_c = 1 \t\t\t#distribution & coil-span factor\n", + "E_ph = rms_value_2*T_ph*K_d*K_c \t\t\t#induced emf\n", + "print 'iv)per phase induced e.m.f is %.1f V '%(E_ph)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)r.m.s value of e.m.f in a conductor is 6.66 V \n", + "ii)r.m.s value of e.m.f in a turn is 13.32 V \n", + "iii)r.m.s value of e.m.f in a coil is 66.6 V \n", + "iv)per phase induced e.m.f is 3822.9 V \n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.11 page no : 44" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 8.\n", + "f = 50. \t\t\t#frequency\n", + "phi = 60.*10**-3 \t\t\t#flux per pole in weber\n", + "Slots = 96. \n", + "n = Slots/Pole \t\t\t#slots per pole\n", + "beeta = 180/n \t\t\t#slot angle \n", + "m = n/3 \t\t\t#slots per pole per phase\n", + "\n", + "# Calculations and Results\n", + "coil_pitch = 10*beeta \t\t\t#10 slots\n", + "alpha = 180-coil_pitch\n", + "K_c = math.cos(math.radians(alpha/2)) \t\t\t#coi;-span factor\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t#distribution factor\n", + "\n", + "conductors_per_slot = 4 \n", + "Z = Slots*conductors_per_slot \t\t\t#total conductors\n", + "Total_turns = Z/2 \n", + "T_ph = Total_turns/3 \t\t\t#turns per phase\n", + "\n", + "#part (i)\n", + "E_ph = 4.44 *K_c *K_d *phi *f *T_ph\n", + "print '\\The phase voltage is %.2f V '%(E_ph)\n", + "\n", + "#part(ii)\n", + "E_line = E_ph*math.sqrt(3)\n", + "print 'The Line Voltage is %.2f V '%(E_line)\n", + "\n", + "#part(iii)\n", + "I_ph = 650\n", + "I_l = I_ph \t\t\t# Star Connection\n", + "kVA_rating = math.sqrt(3)*E_line*I_l\n", + "print 'kVA rating is %.1f kVA '%(kVA_rating/1000)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\\The phase voltage is 788.57 V \n", + "The Line Voltage is 1365.84 V \n", + "kVA rating is 1537.7 kVA \n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.12 page no : 45" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Ns = 600. \t\t\t#synchronous speed in rpm\n", + "Pole = 10.\n", + "l = 30./100 \t\t\t#divided by 100 for centimetre-metre conversion\n", + "Pole_pitch = 35./100 \t\t\t#numerically equal to pi*d/Pole\n", + "Phase = 3.\n", + "conductors_per_slot = 8.\n", + "A1 = Pole_pitch*l \t\t\t#Area of each fundamental pole\n", + "m = 3. \t\t\t#Slot per Pole per Phase\n", + "n = Phase*m \t\t\t#slots per pole\n", + "beeta = 180/n \t\t\t#slot angle\n", + "\n", + "B_m1 = 1.\n", + "B_m3 = 0.3\n", + "B_m5 = 0.2 \t\t\t#amplitude of 1st 3rd and 5th harmonic\n", + "phi_1 = (2/math.pi)*A1*B_m1 \t\t\t#average value of fundamental flux per pole \n", + "f = Ns*Pole/120 \t\t\t#frequency\n", + "\n", + "# Calculations\n", + "Coil_span = (8./9)*180\n", + "alpha = 180-Coil_span\n", + "#pitch factor for 1st 3rd and 5th harmonic\n", + "K_c1 = math.cos(math.radians(alpha/2)) \n", + "K_c3 = math.cos(math.radians(3*alpha/2))\n", + "K_c5 = math.cos(math.radians(5*alpha/2))\n", + "\n", + "# using K_dx = math.sin(m*x*beeta*(math.pi/180)/2) /(m*math.sin(x*beeta*(math.pi/180)/2))\n", + "#distribution factor for 1st 3rd and 5th harmonic\n", + "K_d1 = math.sin(math.radians(m*1*beeta/2)) /(m*math.sin(math.radians(1*beeta/2)))\n", + "K_d3 = math.sin(math.radians(m*3*beeta/2)) /(m*math.sin(math.radians(3*beeta/2)))\n", + "K_d5 = math.sin(math.radians(m*5*beeta/2)) /(m*math.sin(math.radians(5*beeta/2)))\n", + "\n", + "Slots = n*Pole\n", + "Total_conductors = conductors_per_slot * Slots\n", + "Total_turns = Total_conductors/2\n", + "T_ph = Total_turns/3 \t\t\t#turns per phase\n", + "\n", + "#EMF of 1st 3rd and 5th harmonic\n", + "E_1ph = 4.44 * K_c1 * K_d1*phi_1 * f * T_ph\n", + "E_3ph = E_1ph* (B_m3*K_c3*K_d3)/(B_m1*K_c1*K_d1)\n", + "E_5ph = E_1ph* (B_m5*K_c5*K_d5)/(B_m1*K_c1*K_d1)\n", + "\n", + "# Results\n", + "# using E_xph = E_1ph* (B_mx*K_cx*K_dx)/(B_m1*K_c1*K_d1)\n", + "E_ph = math.sqrt( E_1ph**2 + E_3ph**2 + E_5ph**2 )\n", + "print 'Phase value of induced e.m.f is %.2f V '%(E_ph)\n", + "E_line = math.sqrt(3) * math.sqrt( E_1ph**2 + E_5ph**2 )\t\t\t#no 3rd harmonic appears in line value\n", + "print 'line value of induced e.m.f is %.2f V '%(E_line)\n", + "\n", + "print 'Answer mismatches due to approximation'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Phase value of induced e.m.f is 1711.94 V \n", + "line value of induced e.m.f is 2916.65 V \n", + "Answer mismatches due to approximation\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.13 page no : 47" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 16.\n", + "phi = 0.03 \t\t\t#flux per pole\n", + "Ns = 375. \t\t\t#synchronous speed in rpm\n", + "\n", + "# Calculations and Results\n", + "f = Ns*Pole/120 \t\t\t#frequency\n", + "print 'frequency is %.0f Hz '%(f)\n", + "Slots = 144\n", + "n = Slots/Pole \t\t\t#slots per pole\n", + "m = n/3 \t\t\t#slots per pole per phase\n", + "beeta = 180/n \t\t\t#slot angle\n", + "K_c = 1 \t\t\t#assuming Full-Pitch coil\n", + "Conductors_per_slot = 10\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t#distribution factor\n", + "\n", + "Total_conductors = Slots*Conductors_per_slot\n", + "Total_turns = Total_conductors/2\n", + "T_ph = Total_turns/3 \t\t\t#turns per phase\n", + "E_ph = 4.44* K_c* K_d*phi* f* T_ph\n", + "E_line = E_ph*math.sqrt(3)\n", + "print 'line voltage is %.2f V '%(E_line)\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "frequency is 50 Hz \n", + "line voltage is 2657.20 V \n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.14 page no : 48" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Ns = 250. \t\t\t#Speed in rpm\n", + "f = 50. \t\t\t#frequency\n", + "I_l = 100.\n", + "Slots = 216.\n", + "Conductors_per_slot = 5\n", + "Pole = 120.*f/Ns\n", + "phi = 30.*10**-3\t\t\t#flux per pole in weber\n", + "Z = Slots*Conductors_per_slot \t\t\t#Total Conductors\n", + "Z_ph = Z/3 \t\t\t#conductors per phase\n", + "T_ph = Z_ph/2 \t\t\t#turns per phase\n", + "n = Slots/Pole \t\t\t#slots per pole\n", + "m = n/3 \t\t\t#slots per pole per phase\n", + "beeta = 180./n \t\t\t#Slot angle\n", + "\n", + "# Calculations\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t#distribution factor\n", + "\n", + "e_av = 2*f*phi \t\t\t#Average Value of EMF in each conductor\n", + "E_c = 1.11*(2*f*phi) \t\t\t#RMS value of EMF in each conductor\n", + "E = 2*E_c*K_d \t\t\t#RMS value of EMF in each turn\n", + "E_ph = T_ph*E \t\t\t#RMS value of EMF in each phase\n", + "E_line = E_ph*math.sqrt(3) \t\t\t#As Star Connected Alternator\n", + "\n", + "# Results\n", + "print 'RMS value of EMF in each phase = %.3f V'%(E_ph)\n", + "print 'RMS value of EMF line value = %.3f V'%(E_line)\n", + "kVA_rating = math.sqrt(3)*E_line*I_l\n", + "print 'kVA rating is %.3f kVA '%(kVA_rating/1000)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "RMS value of EMF in each phase = 1150.602 V\n", + "RMS value of EMF line value = 1992.902 V\n", + "kVA rating is 345.181 kVA \n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.15 page no : 50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 10.\n", + "Slots = 90.\n", + "E_l = 11000.\n", + "f = 50.\n", + "phi = 0.15 \t\t\t#flux per pole in weber\n", + "n = Slots/Pole \t\t\t#slots per pole\n", + "m = n/3 \t\t\t#slots per pole per phase\n", + "beeta = 180/n \t\t\t#slot angle\n", + " \n", + "# Calculations \n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t#distribution factor\n", + "K_c = 1 \t\t\t#coil span factor\n", + "\n", + "E_ph = E_l/math.sqrt(3)\n", + "T_ph = ( E_ph/(4.44*K_c*K_d*phi*f) )\n", + "#T_ph should necessarily be an integer\n", + "Z_ph = (T_ph)*2 \n", + "\n", + "# Results\n", + "print 'Required number of armature conductors is %d'%(Z_ph)\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required number of armature conductors is 397\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.16 page no : 50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 10.\n", + "Ns = 600. \t\t\t#speen in rpm\n", + "conductor_per_slot = 8.\n", + "n = 12. \t\t\t#slots per pole\n", + "Slots = Pole*n \n", + "m = n/3 \t\t\t#slots per pole per phase \n", + "beeta = 180/n \t\t\t#slot angle\n", + "alpha = 2*beeta \t\t\t#short by 2 slots\n", + "\n", + "#flux per pole corresponding to 1st 3rd and 5th harmonic\n", + "phi_1 = 100*10**-3\n", + "phi_3 = (33./100)*phi_1\n", + "phi_5 = (20./100)*phi_1\n", + "\n", + "#coil span factor corresponding to 1st 3rd and 5th harmonic\n", + "K_c1 = math.cos(math.radians( alpha/2))\n", + "K_c3 = math.cos(math.radians( 3*alpha/2))\n", + "K_c5 = math.cos(math.radians( 5*alpha/2))\n", + "\n", + "# using K_dx = math.sin(m*x*beeta /2) /(m*math.sin(x*beeta /2))\n", + "#distribution factor corresponding to 1st 3rd and 5th harmonic\n", + "K_d1 = math.sin(math.radians(m*1*beeta/2)) /(m*math.sin(math.radians(1*beeta /2)))\n", + "K_d3 = math.sin(math.radians(m*3*beeta/2)) /(m*math.sin(math.radians(3*beeta /2)))\n", + "K_d5 = math.sin(math.radians(m*5*beeta/2)) /(m*math.sin(math.radians(5*beeta /2)))\n", + "\n", + "Z = conductor_per_slot*n*Pole \t\t\t#Total Conductors\n", + "Zph = Z/3 \t\t\t#conductors per phase\n", + "T_ph = Zph/2 \t\t\t#turns per phase\n", + "\n", + "f = Ns*Pole/120\n", + "E_1ph = 4.44*K_c1*K_d1*phi_1*f*T_ph\n", + "E_3ph = 4.44*K_c3*K_d3*phi_3*f*T_ph\n", + "E_5ph = 4.44*K_c5*K_d5*phi_5*f*T_ph\n", + "\n", + "E_ph = math.sqrt( E_1ph**2 + E_3ph**2 + E_5ph**2 )\n", + "\n", + "# Results\n", + "print 'Phase value of induced e.m.f is %.0f V '%(E_ph)\n", + "E_line = math.sqrt(3)*math.sqrt( E_1ph**2 + E_5ph**2 ) \t\t\t#In a line value 3rd harmonic doesnt appear\n", + "print 'line value of induced e.m.f is %d V '%(E_line)\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Phase value of induced e.m.f is 3330 V \n", + "line value of induced e.m.f is 5691 V \n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.17 page no : 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 6.\n", + "Ns = 1000. \t\t\t#speed in rpm\n", + "d = 28./100 \t\t\t#Divided by 100 to convert from centimeters to metres\n", + "l = 23./100 \t\t\t#Divided by 100 to convert from centimeters to metres\n", + "m = 4. \t \t\t#slots per pole per phase\n", + "B_m1 = 0.87 \t\t\t#amplitude of 1st harmonic component of flux density\n", + "B_m3 = 0.24 \t\t\t#amplitude of 3rd harmonic component of flux density\n", + "Conductors_per_slot = 8\n", + "f = Ns*Pole/120 \t\t\t#frequency\n", + "A1 = math.pi*d*l/Pole \t\t\t#area of each fundamental pole\n", + "phi_1 = (2/math.pi)*A1*B_m1 \t\t\t#flux per pole in weber\n", + "n = m*3 \t\t \t#slots per pole\n", + "beeta = 180/n \t\t\t#slot angle\n", + "alpha = beeta \t\t\t#because of 1 slot short\n", + "\n", + "# Calculations\n", + "K_c1 = math.cos(math.radians(alpha/2)) \t\t\t#coil span factor corresponding to 1st harmonic\n", + "K_c3 = math.cos(math.radians(3*alpha/2))\t\t\t#coil span factor corresponding to 3rd harmonic\n", + "# using K_dx = math.sin(m*x*beeta*(math.pi/180)/2) /(m*math.sin(x*beeta*(math.pi/180)/2))\n", + "K_d1 = math.sin(math.radians(m*1*beeta/2)) /(m*math.sin(math.radians(1*beeta/2))) \t\t\t#distribution factor corresponding to 1st harmonic\n", + "K_d3 = math.sin(math.radians(m*3*beeta/2)) /(m*math.sin(math.radians(3*beeta/2))) \t\t\t#distribution factor corresponding to 3rd harmonic\n", + "\n", + "Slots = n*Pole\n", + "Z = Slots*Conductors_per_slot \t\t\t#total number of conductors\n", + "Z_ph = Z/3 \t\t\t#conductors per phase\n", + "T_ph = Z_ph/2 \t\t\t#turns per phase\n", + "\n", + "E_1ph = 4.44*K_c1*K_d1*phi_1*f*T_ph\n", + "E_3ph = E_1ph* (B_m3*K_c3*K_d3)/(B_m1*K_c1*K_d1) \t\t\t#using E_xph = E_1ph* (B_mx*K_cx*K_dx)/(B_m1*K_c1*K_d1)\n", + "E_ph = math.sqrt( E_1ph**2 + E_3ph**2 )\n", + "print 'r.m.s value of resultant voltage is %.1f V'%(E_ph)\n", + "E_line = math.sqrt(3)*E_1ph \t\t\t#For line Value 3rd harmonic does not appear\n", + "print 'line voltage is %.3f V'%(E_line)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "r.m.s value of resultant voltage is 383.7 V\n", + "line voltage is 654.560 V\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.18 page no : 53" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 125.\n", + "V_ph = V_L\n", + "VA = 600.*10**3\n", + "I_L = VA/(math.sqrt(3)*V_L) \t\t\t# Because VA = math.sqrt(3)* V_L * I_L\n", + "I_ph = I_L/(math.sqrt(3))\n", + "\n", + "# Calculations and Results\n", + "#After Reconnection\n", + "V_ph = 125\n", + "V_L = V_ph*math.sqrt(3)\n", + "print 'New rating in volts is %.3f V'%(V_L)\n", + "#Winding Impedances remain the same\n", + "I_ph = 1600\n", + "I_L = I_ph\n", + "\n", + "print 'New rating in amperes is %.0f A'%(I_L)\n", + "kVA = math.sqrt(3)*V_L*I_L*(10**-3)\n", + "print 'New rating in kVA is %.0f kVA'%(kVA)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New rating in volts is 216.506 V\n", + "New rating in amperes is 1600 A\n", + "New rating in kVA is 600 kVA\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.19 page no : 55" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Pole = 4.\n", + "f = 50. \t\t\t#frequency\n", + "phi = 0.12 \t\t\t#flux per pole in weber\n", + "m = 4. \t\t\t# slot per pole per phase\n", + "conductor_per_slot = 4.\n", + "coilspan = 150.\n", + "Ns = 120*f/Pole \t\t\t#synchronous speed in rpm\n", + "n = m*3 \t \t\t#Slots per pole\n", + "beeta = 180/n \t\t\t#slot angle\n", + "\n", + "# Calculations\n", + "K_d = math.sin(math.radians(m*beeta/2)) /(m*math.sin(math.radians(beeta/2))) \t\t\t# distribution factor\n", + "alpha = 180-coilspan \t\t\t#angle of short pitch\n", + "K_c = math.cos((math.pi/180)*alpha/2) \t\t\t#coil span factor\n", + "Z = m*(n*Pole) \t\t\t# Also equal to (conductors/slots)*slots\n", + "Z_ph = Z/3 \t\t\t#conductors per phase\n", + "T_ph = Z_ph/2 \t\t\t#turns per phase\n", + "E_ph = 4.44*K_c*K_d*phi*f*T_ph\n", + "E_line = math.sqrt(3)*E_ph\n", + "\n", + "# Results\n", + "print 'e.m.f generated is %.2f Vphase, %.2f Vline)'%(E_ph,E_line)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "e.m.f generated is 788.57 Vphase, 1365.84 Vline)\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/DC_Machines_and_Synchronous_Machines/ch5.ipynb b/DC_Machines_and_Synchronous_Machines/ch5.ipynb new file mode 100755 index 00000000..4aca598c --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/ch5.ipynb @@ -0,0 +1,1612 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:ae2b9384b1b13f79321d75082b020b6a54688771e761bc6446ad00de14bf068e" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 5 : Methods for Calculating Regulation of Alternator" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.1 page no : 12" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "P = 1000.*10**3 \t\t\t#load power\n", + "phi = math.acos(math.radians(0.8)) \t\t\t#power factor lagging angle\n", + "V_L = 11.*10**3 \t\t\t#rated terminal voltae\n", + "R_a = 0.4 \t\t\t#armature resistance per phase\n", + "X_s = 3.\t\t\t#synchronous reactance per phase\n", + "\n", + "# Calculations\n", + "I_L = P/(math.sqrt(3)*V_L*math.cos(math.radians(phi)))\n", + "I_aph = I_L \t\t\t#for star connected load\n", + "I_a = I_L\t\t\t#current through armature\n", + "V_ph = V_L/math.sqrt(3) \t\t\t#rated terminal volatge phase value\n", + "\n", + "E_ph = math.sqrt( (V_ph*math.cos(math.radians(phi))+I_a*R_a)**2+(V_ph*math.sin(math.radians(phi))+I_a*X_s)**2 ) \t\t\t#emf generated phase value\n", + "E_line = E_ph*math.sqrt(3) \t\t\t#line value of emf generated\n", + "regulation = 100*(E_ph-V_ph)/V_ph \t\t\t#pecentage regulation\n", + "\n", + "# Results\n", + "print 'Line value of e.m.f generated is %.2f kV \\nRegulation is %.3f percent'%(E_line*10**-3,regulation)\n", + "\n", + "# note : book answer is wrong.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line value of e.m.f generated is 11.05 kV \n", + "Regulation is 0.428 percent\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.2 Page no : 14" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "VA = 1200.*10**3\n", + "V_L = 6600.\n", + "R_a = 0.25 \t\t\t#armature resistance per phase\n", + "X_s = 5.\t\t\t#synchronous reactance per phase\n", + "\n", + "# Calculations and Results\n", + "I_L = VA/(math.sqrt(3)*V_L)\n", + "I_aph = I_L \t\t\t#for star connected load\n", + "I_a = I_L\n", + "V_ph = V_L/math.sqrt(3)\n", + "\n", + "#Part(i)\n", + "phi1 = math.acos(0.8)\t\t\t#and lagging\n", + "E_ph1 = math.sqrt( (V_ph*math.cos(phi1)+I_a*R_a)**2+(V_ph*math.sin(phi1)+I_a*X_s)**2 )\n", + "regulation = 100*(E_ph1-V_ph)/V_ph \t\t\t#percentage regulation\n", + "print 'i)Regulation at 0.8 lagging pf is %.2f percent'%(regulation)\n", + "#Part(ii)\n", + "phi2 = math.acos(0.8)\t\t\t#and leading\n", + "E_ph2 = math.sqrt( (V_ph*math.cos(phi2)+I_a*R_a)**2+(V_ph*math.sin(phi2)-I_a*X_s)**2 )\n", + "regulation2 = 100*(E_ph2-V_ph)/V_ph \t\t\t#percentage regulation\n", + "print 'ii)Regulation at 0.8 leading pf is %.f percent'%(regulation2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Regulation at 0.8 lagging pf is 9.33 percent\n", + "ii)Regulation at 0.8 leading pf is -7 percent\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.3 Page no : 17" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "#full load\n", + "V_L_FL = 1100.\n", + "V_ph_FL = V_L_FL/math.sqrt(3)\n", + "\n", + "# Calculations\n", + "#no load\n", + "V_L_NL = 1266\n", + "E_line = V_L_NL\n", + "E_ph = E_line/math.sqrt(3)\n", + "regulation = 100*(E_ph-V_ph_FL)/V_ph_FL\n", + "\n", + "# Results\n", + "print 'Regulation at full load is %.2f percent'%(regulation)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Regulation at full load is 15.09 percent\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.4 Page no : 23" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 866.\n", + "VA = 100.*10**3\n", + "I_L = VA/(math.sqrt(3)*V_L) \t\t\t#because VA = math.sqrt(3)*V_L*I_L\n", + "I_aph = I_L\t\t\t#full load and star connected alternator\n", + "V_ph = V_L/math.sqrt(3)\n", + "\n", + "# Calculations\n", + "#Graph is plotted and V_oc_ph and I_asc_Ph is obtained for \n", + "#SCC for I_asc = 66.67 A\n", + "I_f = 2.4 # A\n", + "#OCC for I_f = 2.4 A\n", + "V_oc_ph = 240 # V\n", + "\n", + "#for measruemnt of impedance\n", + "V_oc_ph = 240 \t\t\t#for I_f = 2.4..From o.c.c graph\n", + "I_asc_ph = 66.67 \t\t\t#for I_f = 2.4...From s.c.c graph\n", + "Z_s = V_oc_ph/I_asc_ph\n", + "R_a = 0.15\n", + "X_s = math.sqrt( Z_s**2-R_a**2 )\n", + "\n", + "V_ph_FL = 500.\n", + "phi = math.acos(0.8) \t\t\t#lagging pf\n", + "E_ph = math.sqrt((V_ph_FL*math.cos(phi)+I_aph*R_a)**2+(V_ph_FL*math.sin(phi)+I_aph*X_s)**2)\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "\n", + "# Results\n", + "print 'Full-load regulation at 0.8 lagging pf is %.2f percent '%(regulation )\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full-load regulation at 0.8 lagging pf is 35.57 percent \n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.5 Page no : 25" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_OC_line = 230.\n", + "I_asc = 12.5 \t\t\t# when I_f = 0.38\n", + "V_OC_ph = V_OC_line/math.sqrt(3)\n", + "Z_s = V_OC_ph/I_asc \n", + "\n", + "R_a = 1.8/2 \t\t\t#1.8 is between terminals..0.9 is per phase\n", + "X_s = math.sqrt(Z_s**2-R_a**2)\n", + "\n", + "I_a = 10.\t\t\t# when regulation is needed\n", + "V_L = 230.\n", + "V_ph = V_L/math.sqrt(3)\n", + "\n", + "# Calculations and Results\n", + "#Part(i)\n", + "phi1 = math.acos(0.8) \t\t\t#and lagging\n", + "E_ph1 = math.sqrt((V_ph*math.cos(phi1)+I_a*R_a)**2+(V_ph*math.sin(phi1)+I_a*X_s)**2)\n", + "regulation1 = 100*(E_ph1-V_ph)/V_ph\n", + "print 'Regulation for 10 A at 0.8 lagging pf is %.2f percent'%(regulation1)\n", + "#Part(ii)\n", + "phi2 = math.acos(0.8) \t\t\t#and leading\n", + "E_ph2 = math.sqrt((V_ph*math.cos(phi2)+I_a*R_a)**2+(V_ph*math.sin(phi2)-I_a*X_s)**2)\n", + "regulation2 = 100*(E_ph2-V_ph)/V_ph\n", + "print 'Regulation for 10 A at 0.8 leading pf is %.2f percent'%(regulation2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Regulation for 10 A at 0.8 lagging pf is 64.47 percent\n", + "Regulation for 10 A at 0.8 leading pf is -11.01 percent\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.6 Page no : 31" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "phi = math.acos(0.8)\n", + "VA = 1000.*10**3\n", + "V_L = 1905.\n", + "V_ph = V_L/math.sqrt(3)\n", + "R_a = 0.2\t\t\t#Armature reactance per phase\n", + "\n", + "# Calculations and Results\n", + "#Part(i)\n", + "#Ampere-turn method\n", + "I_L = VA/(math.sqrt(3)*V_L)\n", + "I_aph = I_L\n", + "V_dash = V_ph+I_aph*R_a*math.cos(phi)\t\t\t#V_dash is a dummy quantity and has no significance..it's used only for mapping correcponding current\n", + "F_o = 32 \t\t\t#F_o corresponds to voltage V_dash = 1148.5 from O.C.C graph\n", + "F_AR = 27.5 \t\t\t#Field current required to circulate full-load short circuit current of 303.07A.From SCC F_AR = 27.5\n", + "F_R = math.sqrt( F_o**2 + F_AR**2-2*F_o*F_AR*math.cos(phi+math.pi/2) )\t\t\t#using Comath.sine rule\n", + "\n", + "# for F_R = 53.25 E_ph = 1490 V from O.C.C\n", + "E_ph = 1490.\n", + "regulation1 = 100*(E_ph-V_ph)/V_ph\n", + "print 'Regulation on full-load by ampere-turn method is %.2f percent'%(regulation1)\n", + "\n", + "#Part (ii)\n", + "#Synchronous Impedance method\n", + "\n", + "I_sc = I_L\n", + "I_aph2 = I_sc\n", + "I_f = 27.5\n", + "\n", + "V_OC_ph = 1060. \t\t\t#corresponding to I-f = 27.5 in the graph\n", + "Z_s = V_OC_ph/I_aph2\n", + "X_s = math.sqrt(Z_s**2-R_a**2)\n", + "\n", + "E_ph2 = math.sqrt( (V_ph*math.cos(phi)+I_aph2*R_a)**2+(V_ph*math.sin(phi)+I_aph2*X_s)**2 ) \t\t\t#from phasor diagram\n", + "regulation2 = 100*(E_ph2-V_ph)/V_ph\n", + "print 'Regulation on full-load by synchronous impedance method is %.2f percent'%(regulation2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Regulation on full-load by ampere-turn method is 35.47 percent\n", + "Regulation on full-load by synchronous impedance method is 78.09 percent\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.7 Page no : 39" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "#case(i)\n", + "V_L = 440.\n", + "V_ph = V_L/math.sqrt(3)\n", + "phi = math.acos(0.8)\n", + "\n", + "#armature resistance drop from the graph\n", + "#RS = 1.1 cm and scale = 50 V/cm\n", + "arm_leak_resis = 1.1*50 \t\t\t#armature leakage resistance\n", + "\n", + "OB = V_ph*math.cos(phi)\n", + "AB = V_ph*math.sin(phi) + arm_leak_resis\n", + "E_1ph = math.sqrt( OB**2+AB**2 )\n", + "\n", + "F_f1 = 6.1 \t\t\t#corresponding value from OCC\n", + "F_AR = 3.1*1\n", + "\n", + "# Calculations and Results\n", + "F_R = math.sqrt( F_f1**2 + F_AR**2 -2*F_f1*F_AR*math.cos(math.radians(90+math.acos(math.radians(0.8)))))\n", + "E_ph = 328. \t\t\t#voltage corresponding to F_R = 8.33 A from OCC graph\n", + "regulation1 = 100*(E_ph - V_ph)/V_ph\n", + "print 'i)Regulation for 0.8 pf lagging is %.2f percent '%(regulation1)\n", + "\n", + "#case(ii)\n", + "\n", + "OC = V_ph*math.cos(phi)\n", + "BC = V_ph*math.sin(phi) - arm_leak_resis\n", + "E_1ph = math.sqrt( OC**2+BC**2 )\n", + "\n", + "F_f1 = 6.1 \t\t\t#corresponding value from OCC\n", + "F_R = math.sqrt( F_f1**2 + F_AR**2 -2*F_f1*F_AR*math.cos(math.radians(90-math.acos(math.radians(0.8)))))\n", + "E_ph = 90 \t\t\t#volatge corresponding to F_R = 3.34 A from OCC graph\n", + "regulation2 = 100*(E_ph - V_ph)/V_ph\n", + "print 'ii)Regulation for 0.8 pf leading is %.2f percent '%(regulation2)\n", + "print 'The answer in part ii doesnt match with textbook because of calculation mistake done in last step in the textbook'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Regulation for 0.8 pf lagging is 29.12 percent \n", + "ii)Regulation for 0.8 pf leading is -64.57 percent \n", + "The answer in part ii doesnt match with textbook because of calculation mistake done in last step in the textbook\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.8 Page no : 44" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "P = 1200.*10**3\n", + "V_line = 12000.\n", + "R_a = 2.\n", + "X_s = 35.\t\t\t#armature resistance and synchronous reactance\n", + "phi = math.acos(0.8)\n", + "\n", + "# Calculations\n", + "I_L = P/(math.sqrt(3)*V_line*math.cos(phi))\n", + "I_a = I_L\n", + "V_ph = V_line/math.sqrt(3)\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_a*R_a)**2+(V_ph*math.sin(phi)+I_a*X_s)**2)\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "\n", + "# Results\n", + "print 'Regulation at 0.8 lag power factor is %.2f percent'%(regulation)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Regulation at 0.8 lag power factor is 26.66 percent\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.9 Page no : 45" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 11000. \n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 1000.*1000\n", + "I_L = VA/(V_L*math.sqrt(3))\n", + "\n", + "V_OC_ph = 433/math.sqrt(3)\n", + "I_asc_ph = I_L\n", + "\n", + "Z_s = V_OC_ph /I_asc_ph \t\t\t#ohms per phase\n", + "R_a = 0.45 \t\t\t#ohms per phase\n", + "X_s = math.sqrt(Z_s**2-R_a**2)\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "phi = math.acos(0.8) \t\t\t#lagging\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_L*R_a)**2 +(V_ph*math.sin(phi)+ I_L*X_s)**2)\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "print 'Voltage regulation at 0.8 pf lagging is %f percent'%(regulation)\n", + "\n", + "#part(ii)\n", + "phi = math.acos(0.8) \t\t\t#leading\n", + "E_ph2 = math.sqrt((V_ph*math.cos(phi)+I_L*R_a)**2 +(V_ph*math.sin(phi)- I_L*X_s)**2)\n", + "regulation2 = 100*(E_ph2-V_ph)/V_ph\n", + "print 'Voltage regulation at 0.8 pf lagging is %f percent'%(regulation2)\n", + "print 'Answer mismatches due to improper approximation'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage regulation at 0.8 pf lagging is 2.690067 percent\n", + "Voltage regulation at 0.8 pf lagging is -1.996182 percent\n", + "Answer mismatches due to improper approximation\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.10 Page no : 46" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "VA = 125.*10**3\n", + "V_L = 400.\n", + "V_ph = V_L/math.sqrt(3)\n", + "I_L = VA/(math.sqrt(3)*V_L)\n", + "I_aph = I_L\n", + "\n", + "# Calculations\n", + "I_f = 4.\n", + "I_asc = I_aph/2 \t\t\t#for half load.. refer to graph\n", + "V_OC_line = 140.\n", + "V_OC_ph = V_OC_line/math.sqrt(3)\n", + "I_asc_ph = I_asc\n", + "Z_s = V_OC_ph/I_asc_ph\n", + "R_a = 0.1\n", + "X_s = math.sqrt(Z_s**2-R_a**2) \t\t\t#armature resistance and synchronous reactance\n", + "\n", + "phi = math.acos(0.8)\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_asc*R_a)**2 +(V_ph*math.sin(phi)- I_asc*X_s)**2)\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "\n", + "# Results\n", + "print 'Voltage regulation at 0.8 pf leading for half load is %.2f percent'%(regulation)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage regulation at 0.8 pf leading for half load is -12.39 percent\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.11 Page no : 48" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import roots\n", + "\n", + "# Variables\n", + "V_OC_line = 575.\n", + "V_OC_ph = V_OC_line/math.sqrt(3)\n", + "I_asc_line = 75.\n", + "I_asc_ph = I_asc_line \n", + "I_aph = I_asc_ph\n", + "I_L = I_aph\n", + "\n", + "Z_s = V_OC_ph/I_asc_ph\n", + "R_a = 2.16/2\n", + "X_s = math.sqrt(Z_s**2 - R_a**2)\n", + "\n", + "# Calculations and Results\n", + "#on full load\n", + "E_ph = 6100.\n", + "phi = math.acos(0.8) \t\t\t#leading\n", + "\n", + "#using E_ph = math.sqrt((V_ph*math.cos(phi)+I_a*R_a)**2 +(V_ph*math.sin(phi)- I_a*X_s)**2)\n", + "p = [1, -256.68, -3.71*10**7]\n", + "ans = roots(p)\n", + "V_ph = ans[0] \t\t\t#second root is ignored as its -ve\n", + "V_L = V_ph*math.sqrt(3)\n", + "print 'Rated terminal voltage between the lines is %.3f V '%(V_L)\n", + "VA_rating = math.sqrt(3)*V_L*I_L\n", + "print 'kVA rating of the alternator is %.f kVA'%(VA_rating*10**-3)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Rated terminal voltage between the lines is 10774.515 V \n", + "kVA rating of the alternator is 1400 kVA\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.12 Page no : 49" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import roots\n", + "\n", + "# Variables\n", + "V_L = 6600.\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 1500.*10**3\n", + "I_L = VA/(math.sqrt(3)*V_L)\n", + "I_aph = I_L\n", + "\n", + "# Calculations and Results\n", + "R_a = 0.5\n", + "X_s = 5\t\t\t#armature resistance and synchronous reactance\n", + "phi = math.acos(0.8)\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_aph*R_a)**2 +(V_ph*math.sin(phi)+ I_aph*X_s)**2)\n", + "print 'Induced EMF per phase is %f V'%(E_ph)\n", + "\n", + "#full load \n", + "phi = math.acos(1)\n", + "#using E_ph = math.sqrt((V_ph*math.cos(phi)+I_a*R_a)**2 +(V_ph*math.sin(phi)- I_a*X_s)**2)\n", + "p = [1, 131.215, -1.791*10**7]\n", + "ans = roots(p)\n", + "V_ph = ans[1] \t\t\t#first root is ignored as it is -ve\n", + "print 'Terminal voltage per phase is %f V'%(V_ph)\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced EMF per phase is 4284.243828 V\n", + "Terminal voltage per phase is 4166.921808 V\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.13 Page no : 50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_ph = 2000.\n", + "R_a = 0.8\n", + "I_sc = 100.\n", + "V_OC = 500.\n", + "I_f = 2.5\n", + "Z_s = V_OC/I_sc\n", + "X_s = math.sqrt(Z_s**2 - R_a**2 )\n", + "I_aFL = 100.\n", + "I_a = I_aFL\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "phi = math.acos(1)\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_a*R_a)**2 +(V_ph*math.sin(phi)+ I_a*X_s)**2)\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "print 'i)Voltage regulation is %.2f percent'%(regulation)\n", + "\n", + "#part(ii)\n", + "phi2 = math.acos(0.8)\n", + "E_ph2 = math.sqrt((V_ph*math.cos(phi2)+I_a*R_a)**2 +(V_ph*math.sin(phi2)- I_a*X_s)**2)\n", + "regulation2 = 100*(E_ph2-V_ph)/V_ph\n", + "print 'ii)Voltage regulation is %.2f percent'%(regulation2)\n", + "\n", + "#part(iii)\n", + "phi3 = math.acos(0.71)\n", + "E_ph3 = math.sqrt((V_ph*math.cos(phi3)+I_a*R_a)**2 +(V_ph*math.sin(phi3)+ I_a*X_s)**2)\n", + "regulation3 = 100*(E_ph3-V_ph)/V_ph\n", + "print 'iii)Voltage regulation is %.2f percent'%(regulation3)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Voltage regulation is 6.89 percent\n", + "ii)Voltage regulation is -8.88 percent\n", + "iii)Voltage regulation is 21.11 percent\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.14 Page no : 51" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "VA = 1000.*1000\n", + "V_L = 4600. \n", + "V_ph = V_L/math.sqrt(3)\n", + "I_L = VA/(math.sqrt(3)*V_L)\n", + "I_aph_FL = I_L\n", + "I_aph = I_aph_FL\n", + "I_sc = (150./100)* I_aph_FL\n", + "V_OC_line = 1744\n", + "V_OC_ph = V_OC_line/math.sqrt(3)\n", + "\n", + "# Calculations\n", + "Z_s = V_OC_ph / I_sc\n", + "R_a = 1\n", + "X_s = math.sqrt(Z_s**2-R_a**2)\n", + "\n", + "phi = math.acos(0.8 ) \t\t\t#lagging\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_aph*R_a)**2 +(V_ph*math.sin(phi)+ I_aph*X_s)**2)\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "\n", + "# Results\n", + "print 'Voltage regulation at full load 0.8 pf is %.2f percent'%(regulation)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage regulation at full load 0.8 pf is 19.89 percent\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.15 Page no : 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "\n", + "#part(i) Ampere turn method\n", + "# Variables\n", + "F_O = 37.5\n", + "F_AR = 20.\n", + "V_L = 6600.\n", + "V_ph = V_L/math.sqrt(3)\n", + "\n", + "# Calculations and Results\n", + "#lagging\n", + "phi = math.acos(0.8) \n", + "F_R = math.sqrt((F_O+F_AR*math.sin(phi) )**2 + (F_AR*math.cos(phi))**2 ) \n", + "#E_ph corresponding to F_R can be obtained by plotting open circuit characteristics\n", + "E_ph = 4350\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "print 'i)By Ampere-turn method or MMF methodFull-load regulation at 0.8 lagging pf is %.2f percent'%(regulation)\n", + "#leading\n", + "phi = math.acos(0.8) \n", + "F_R = math.sqrt((F_O-F_AR*math.sin(phi) )**2 + (F_AR*math.cos(phi))**2 ) \n", + "#E_ph corresponding to F_R can be obtained by plotting open circuit characteristics\n", + "E_ph = 3000\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "print 'Full-load regulation at 0.8 leading pf is %.2f percent'%(regulation)\n", + "\n", + "#EMF method\n", + "V_OC_ph = 100\n", + "V_ph = 100\n", + "I_sc = 100*(F_O/F_AR) \t\t\t#times the rated value\n", + "Z_s = V_OC_ph/I_sc\n", + "F_O = 100\n", + "F_AR = Z_s*100\n", + "\n", + "#lagging\n", + "phi = math.acos(0.8)\n", + "F_R = math.sqrt((F_O+F_AR*math.sin(phi) )**2 + (F_AR*math.cos(phi))**2 ) \n", + "regulation = 100*(F_R-V_ph)/V_ph\n", + "print 'iiSynchronous impedance method or EMF method'\n", + "print 'Full-load regulation at 0.8 lagging pf is %.2f percent'%(regulation)\n", + "#leading\n", + "phi = math.acos(0.8)\n", + "F_R = math.sqrt((F_O-F_AR*math.sin(phi) )**2 + (F_AR*math.cos(phi))**2 ) \n", + "regulation = 100*(F_R-V_ph)/V_ph\n", + "print 'Full-load regulation at 0.8 leading pf is %.2f percent'%(regulation)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)By Ampere-turn method or MMF methodFull-load regulation at 0.8 lagging pf is 14.16 percent\n", + "Full-load regulation at 0.8 leading pf is -21.27 percent\n", + "iiSynchronous impedance method or EMF method\n", + "Full-load regulation at 0.8 lagging pf is 38.72 percent\n", + "Full-load regulation at 0.8 leading pf is -19.72 percent\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.16 Page no : 56" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 6000.\n", + "V_ph = V_L/math.sqrt(3)\n", + "I_ph_X_Lph = 0.9*500 \t\t\t#leakage reactance drop in volts = 0.9 cm * 500 V/cm\n", + "phi = math.acos(0.8) \t\t\t#lagging\n", + "\n", + "# Calculations\n", + "E_1ph = math.sqrt( (V_ph*math.cos(phi))**2 + (V_ph*math.sin(phi)+I_ph_X_Lph)**2 ) \t\t\t#From triangle OAB\n", + "F_f1 = 26 \t\t\t#from OCC\n", + "F_AR = 2.9*5 \t\t\t#2.9cm * 5 A/cm\n", + "\n", + "F_R = math.sqrt(F_f1**2 + F_AR**2 -2*F_AR*F_f1*math.cos(phi+ (math.pi/2)) )\n", + "\n", + "# Results\n", + "print 'Required field current is %.2f A'%(F_R)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required field current is 36.59 A\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.17 Page no : 58" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 400.\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 40.*10**3\n", + "I_L = VA/(math.sqrt(3)*V_L) \n", + "I_aph = I_L\n", + "\n", + "# Calculations and Results\n", + "I_aph_X_Lph = 0.65*50 \t\t\t#leakage reactance drop in volts = 2.4 cm * 500 V/cm\n", + "X_Lph = I_aph_X_Lph/ I_aph\n", + "print 'Armature leakage reactance is %.3f ohms'%(X_Lph)\n", + "phi = math.acos(0.8) \t\t\t#lagging\n", + "E_ph = math.sqrt((V_ph*math.cos(phi))**2 +(V_ph*math.sin(phi)+ I_aph_X_Lph)**2)\n", + "F_f1 = 15.6 \t\t\t#as obtained from OCC corresponding to this E_ph\n", + "\n", + "F_AR = 2.3*3 \t\t\t#2.3cm * 3 A/cm\n", + "print 'Armature reaction is %.1f '%(F_AR)\n", + "F_R = math.sqrt(F_f1**2 + F_AR**2 -2*F_AR*F_f1*math.cos(phi+ (math.pi/2)) ) \t\t\t#math.comath.sine rule to Triangle OAB\n", + "E_ph = 267.5 \t\t\t#corresponding to F_R from open circiut characteristics\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "print 'Voltage regulation at 0.8 pf lagging is %.1f percent'%(regulation)\n", + "\n", + "\n", + "#Note:This answer doesnt match with textbook as it has been reciprocated in textbook\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature leakage reactance is 0.563 ohms\n", + "Armature reaction is 6.9 \n", + "Voltage regulation at 0.8 pf lagging is 15.8 percent\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.18 Page no : 60" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "VA = 10.*10**3\n", + "V_L = 11.*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "I_ph_X_Lph = 2.4*500 \t\t\t#leakage reactance drop in volts = 2.4 cm * 500 V/cm\n", + "\n", + "# Calculations\n", + "I_ph_R_aph = VA/(math.sqrt(3)*V_L)\n", + "phi = math.acos(0.8)\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_ph_R_aph)**2 +(V_ph*math.sin(phi)+ I_ph_X_Lph)**2)\n", + "F_f1 = 109 \t\t\t#obtained from open circuit characteristics corresponding to calculated E_ph\n", + "F_AR = 2.8*10 \t\t\t#2.8cm * 10 A/cm\n", + "F_R = math.sqrt(F_f1**2 + F_AR**2 -2*F_AR*F_f1*math.cos(phi+ (math.pi/2)) ) \t\t\t#math.comath.sine rule to Triangle OAB\n", + "E_ph = 7700. \t\t\t#corresponding to F_R from open circiut characteristics\n", + "\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "\n", + "# Results\n", + "print 'Voltage regulation at full-load 0.8 pf lagging is %.2f percent'%(regulation)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage regulation at full-load 0.8 pf lagging is 21.24 percent\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.19 Page no : 63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import roots\n", + "\n", + "# Variables\n", + "VA = 2000.*1000\n", + "V_L = 11000.\n", + "V_ph = V_L/math.sqrt(3)\n", + "R_a = 0.3\n", + "X_s = 5. \t\t\t#armature resistance and synchronous reactance\n", + "\n", + "# Calculations\n", + "#case (i)\n", + "phi = math.acos(0.8) \t\t\t#lagging\n", + "I_L = VA/(math.sqrt(3)*V_L) \n", + "I_a = I_L\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_a*R_a)**2 +(V_ph*math.sin(phi)+ I_a*X_s)**2)\n", + "\n", + "#using E_ph = math.sqrt((V_ph*math.cos(phi)+I_aph*R_a)**2 +(V_ph*math.sin(phi)+ I_aph*X_s)**2)\n", + "#we get V_ph**2 -579.4455 V_ph -44653301.91 = 0\n", + "p = [1, -579.4455, -44653301.91]\n", + "ans = roots(p)\n", + "V_ph = ans[0] \t\t#second root is ignored as its -ve\n", + "print 'Terminal voltage is %.4f V'%(V_ph)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Terminal voltage is 6978.3131 V\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.20 Page no : 64" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import roots\n", + "\n", + "# Variables\n", + "R_a = 0.6\n", + "X_s = 6. \t\t\t#armature resistance and synchronous reactance per phase\n", + "E_L = 6599.\n", + "E_ph = E_L/math.sqrt(3)\n", + "I_L = 180.\n", + "I_a = I_L\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "# using E_ph = math.sqrt((V_ph*math.cos(phi)+I_a*R_a)**2 +(V_ph*math.sin(phi)+ I_a*X_s)**2) and solving for V_ph\n", + "p = [1 ,1135.83, -13338836.49]\n", + "ans = roots(p)\n", + "V_ph = ans[1]\n", + "V_L = V_ph*math.sqrt(3)\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "\n", + "phi = math.acos(0.9)\n", + "theta = math.atan((I_a*X_s+V_ph*math.sin(phi) )/(E_ph))\n", + "delta = theta-phi\n", + "print 'i)0.9 laggingTerminal voltage is %.2f VVoltage regulation is %.2f percentLoad angle is %.2f degrees'%(V_ph*math.sqrt(3),regulation,delta*180/math.pi)\n", + "\n", + "#part(ii)\n", + "phi_2 = math.acos(0.8)\n", + "p = [1, -941.53, -11399574.87]\n", + "ans = roots(p) \n", + "V_ph = ans[0] \t\t\t#second root is ignored as its -ve\n", + "V_L = V_ph*math.sqrt(3)\n", + "regulation2 = 100*(E_ph-V_ph)/V_ph\n", + "delta_2 = math.asin( (math.tan(phi)*(V_ph*math.cos(phi_2)+I_a*R_a) -I_a*X_s )/E_ph )\n", + "print 'ii)0.8 leadingTerminal voltage is %.2f VVoltage regulation is %.2f percentLoad angle is %.2f degrees'%(V_L,regulation2,delta_2*180/math.pi)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)0.9 laggingTerminal voltage is 5418.22 VVoltage regulation is 21.79 percentLoad angle is 6.83 degrees\n", + "ii)0.8 leadingTerminal voltage is 6719.93 VVoltage regulation is -1.80 percentLoad angle is 7.17 degrees\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.21 Page no : 66" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_ph = 2000.\n", + "R_a = 0.8\n", + "I_sc = 100.\n", + "I_a = I_sc\n", + "V_OC = 500.\n", + "I_f = 2.5\n", + "Z_s = V_OC/I_sc\n", + "\n", + "X_s = math.sqrt(Z_s**2- R_a**2)\n", + "I_a_FL = 100.\n", + "\n", + "# Calculations and Results\n", + "#Part(i)\n", + "phi1 = math.acos(1) \t\t\t#and lagging\n", + "E_ph1 = math.sqrt((V_ph*math.cos(phi1)+I_a*R_a)**2+(V_ph*math.sin(phi1)+I_a*X_s)**2)\n", + "regulation1 = 100*(E_ph1-V_ph)/V_ph\n", + "print 'Regulation at upf is %.2f percent'%(regulation1)\n", + "\n", + "#Part(ii)\n", + "phi2 = math.acos(0.8) \n", + "E_ph2 = math.sqrt((V_ph*math.cos(phi2)+I_a*R_a)**2+(V_ph*math.sin(phi2)-I_a*X_s)**2)\n", + "regulation2 = 100*(E_ph2-V_ph)/V_ph\n", + "print 'Regulation at 0.8 leading pf is %.2f percent'%(regulation2)\n", + "\n", + "#Part(iii)\n", + "phi3 = math.acos(0.71) \n", + "E_ph3 = math.sqrt((V_ph*math.cos(phi3)+I_a*R_a)**2+(V_ph*math.sin(phi3)+I_a*X_s)**2)\n", + "regulation3 = 100*(E_ph3-V_ph)/V_ph\n", + "print 'Regulation at 0.71 lagging pf is %.2f percent'%(regulation3)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Regulation at upf is 6.89 percent\n", + "Regulation at 0.8 leading pf is -8.88 percent\n", + "Regulation at 0.71 lagging pf is 21.11 percent\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.22 Page no : 68" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V = 600.\n", + "VA = 60.*10**3\n", + "I_sc = 210.\n", + "V_oc = 480.\n", + "I_f = 10.\n", + "R_a = 0.2\n", + "\n", + "I = VA/V \t\t\t#VA = V*I and alternator is math.single phase\n", + "I_a = I\n", + "\n", + "# Calculations and Results\n", + "Z_s = V_oc/I_sc \t\t\t#Synchronous Impedance\n", + "X_s = math.sqrt(Z_s**2-R_a**2) \t\t\t#SYnchronous reactance\n", + "print 'Synchronous impedances is %f ohms and synchronous reactance is %f ohms'%(Z_s,X_s)\n", + "\n", + "#PART (i)\n", + "phi1 = math.acos(0.8) \t\t\t#and lagging\n", + "E1 = math.sqrt((V*math.cos(phi1)+I_a*R_a)**2+(V*math.sin(phi1)+I_a*X_s)**2) \t\t\t#plus sign for lagging power factor\n", + "regulation1 = 100*(E1-V)/V\n", + "print 'Regulation at 0.8 lagging pf is %.2f percent '%(regulation1 )\n", + "\n", + "#PART (ii)\n", + "phi2 = math.acos(1) \n", + "E2 = math.sqrt((V*math.cos(phi2)+I_a*R_a)**2+(V*math.sin(phi2)+I_a*X_s)**2) \n", + "regulation2 = 100*(E2-V)/V\n", + "print 'Regulation at UNITY pf is %.2f percent '%(regulation2 )\n", + "\n", + "#PART (iii)\n", + "phi3 = math.acos(0.6) \t\t\t#and leading \n", + "E3 = math.sqrt((V*math.cos(phi3)+I_a*R_a)**2+(V*math.sin(phi3)-I_a*X_s)**2) \t\t\t#minus sign for leading power factor\n", + "regulation3 = 100*(E3-V)/V\n", + "print 'Regulation at 0.6 leading pf is %.2f percent '%(regulation3 )\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronous impedances is 2.285714 ohms and synchronous reactance is 2.276947 ohms\n", + "Regulation at 0.8 lagging pf is 28.60 percent \n", + "Regulation at UNITY pf is 10.08 percent \n", + "Regulation at 0.6 leading pf is -23.98 percent \n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.23 Page no : 69" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 3300.\n", + "V_ph = V_L/math.sqrt(3)\n", + "I_a = 100.\n", + "I_f = 5.\n", + "V_OC_line = 900. \n", + "V_OC_ph = V_OC_line/math.sqrt(3) \n", + "R_a = 0.8 \t\t\t#armature resistance\n", + "I_aph = I_a\n", + "Z_s = V_OC_ph/I_aph\n", + "X_s = math.sqrt(Z_s**2-R_a**2) \t\t\t#synchronous reactance\n", + "\n", + "# Calculations and Results\n", + "#Part(i)\n", + "phi1 = math.acos(0.8) \t\t\t#and lagging\n", + "E_ph1 = math.sqrt((V_ph*math.cos(phi1)+I_a*R_a)**2+(V_ph*math.sin(phi1)+I_a*X_s)**2)\n", + "regulation1 = 100*(E_ph1-V_ph)/V_ph\n", + "print 'Regulation at 0.8 lagging is %.2f percent'%(regulation1)\n", + "\n", + "#Part(ii)\n", + "phi2 = math.acos(0.8) \t\t\t#and leading\n", + "E_ph2 = math.sqrt((V_ph*math.cos(phi2)+I_a*R_a)**2+(V_ph*math.sin(phi2)-I_a*X_s)**2)\n", + "regulation2 = 100*(E_ph2-V_ph)/V_ph\n", + "print 'Regulation at 0.8 leading pf is %.2f percent'%(regulation2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Regulation at 0.8 lagging is 21.03 percent\n", + "Regulation at 0.8 leading pf is -9.55 percent\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.24 Page no : 70" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 13500.\n", + "R_a = 1.5 \n", + "X_s = 30. \t\t\t#armature resistance and synchronous reactance\n", + "V_ph = V_L/math.sqrt(3)\n", + "\n", + "# Calculations and Results\n", + "#CASE 1\n", + "phi1 = math.acos(0.8)\n", + "P_out = 1280*10**3\n", + "I_L = P_out/ (math.sqrt(3)*V_L*math.cos(phi1) ) \t\t\t#because P_out = math.sqrt(3)*V_L*I_L*math.cos(phi)\n", + "\n", + "I_a = I_L\n", + "E_ph = math.sqrt((V_ph*math.cos(phi1)+I_a*R_a)**2+(V_ph*math.sin(phi1)+I_a*X_s)**2)\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "print 'Regulation at 0.8 lagging power factor is %.2f percent'%(regulation)\n", + "\n", + "#Case 2\n", + "phi2 = math.acos(1)\n", + "I_L = P_out/ (math.sqrt(3)*V_L*math.cos(phi2) ) \t\t\t#because P_out = math.sqrt(3)*V_L*I_L*math.cos(phi)\n", + "\n", + "I_a = I_L\n", + "E_ph = math.sqrt((V_ph*math.cos(phi2)+I_a*R_a)**2+(V_ph*math.sin(phi2)+I_a*X_s)**2)\n", + "regulation2 = 100*(E_ph-V_ph)/V_ph\n", + "print 'Regulation at unity power factor is %.2f percent'%(regulation2)\n", + "\n", + "#case 3\n", + "phi3 = math.acos(0.8)\n", + "I_L = P_out/ (math.sqrt(3)*V_L*math.cos(phi3) ) \t\t\t#because P_out = math.sqrt(3)*V_L*I_L*math.cos(phi)\n", + "I_a = I_L\n", + "E_ph = math.sqrt((V_ph*math.cos(phi3)+I_a*R_a)**2+(V_ph*math.sin(phi3)-I_a*X_s)**2)\t\t\t# minus sign in the second bracket beacuse of leading pf\n", + "regulation3 = 100*(E_ph-V_ph)/V_ph\n", + "print 'Regulation at 0.8 leading power factor is %.2f percent'%(regulation3)\n", + "\n", + "# note : rounding off error" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Regulation at 0.8 lagging power factor is 18.60 percent\n", + "Regulation at unity power factor is 3.23 percent\n", + "Regulation at 0.8 leading power factor is -11.99 percent\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.26 Page no : 72" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 11.*10**3\n", + "VA_rating = 10.**6\n", + "R_a = 2.2 \t\t\t#alternator resistance\n", + "phi = math.acos(0.8)\n", + "\n", + "# Calculations\n", + "I_L = VA_rating/(math.sqrt(3)*V_L)\t\t\t#VA = math.sqrt(3)V_L*I_L\n", + "I_a = I_L\n", + "V_ph = V_L/math.sqrt(3)\n", + "regulation = 24.\n", + "\n", + "E_ph = ((regulation/100)+1)*V_ph \t\t\t# because regulation = 100*(E_ph-V_ph)/V_ph\n", + "#using E_ph = math.sqrt((V_ph*math.cos(phi)+I_a*R_a)**2+(V_ph*math.sin(phi)+I_a*X_s)**2)\n", + "X_s = (math.sqrt(E_ph**2-((V_ph*math.cos(phi)+I_a*R_a)**2))-V_ph*math.sin(phi))*(1/I_a)\n", + "\n", + "phi1 = math.acos(0.8)\n", + "E_ph = math.sqrt((V_ph*math.cos(phi1)+I_a*R_a)**2+(V_ph*math.sin(phi1)-I_a*X_s)**2)\n", + "regulation1 = 100*(E_ph-V_ph)/V_ph\n", + "\n", + "# Results\n", + "print 'Regulation at 0.8 leading power factor is %.2f percent'%(regulation1)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Regulation at 0.8 leading power factor is -13.90 percent\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.27 Page no : 73" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 220.\n", + "VA = 100.*10**3\n", + "R_a = 0.1 \t\t\t#effective resistacne of alternator\n", + "X_a = 0.5 \t\t\t#leakage reactance\n", + "X_ar = 2*X_a\n", + "\n", + "Z_s = complex(R_a,X_a+X_ar)\n", + "\n", + "# Calculations and Results\n", + "#Part(1)\n", + "phi = math.acos(0.4)\n", + "V_ph = V_L/math.sqrt(3)\n", + "I_L = VA/(math.sqrt(3)*V_L)\t\t\t#VA = math.sqrt(3)*V_L*I_L\n", + "I_a = I_L\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_a*R_a)**2+(V_ph*math.sin(phi)+I_a*(X_a+X_ar))**2)\n", + "print 'i)Required noload voltage is %.3f V'%(E_ph)\n", + "\n", + "#Part(2)\n", + "V_ph2 = 0\n", + "E_ph2 = math.sqrt((V_ph2*math.cos(phi)+I_a*R_a)**2+(V_ph2*math.sin(phi)+I_a*(X_a+X_ar))**2)\n", + "print 'ii)Required noload voltage is %.3f V'%(E_ph2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Required noload voltage is 515.848 V\n", + "ii)Required noload voltage is 394.522 V\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.28 Page no : 74" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 2000.\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 1000.*10**3\n", + "I_L = VA/(math.sqrt(3)*V_L) \t\t\t#because VA = math.sqrt(3)*V_L*I_L\n", + "I_aph = I_L\n", + "\n", + "I_f = 28.5\t\t\t#for this I_aph = 288.67513 as obtained from SCC graph\n", + "V_oc_ph = 1060.\t\t\t#for I_f = 28.5 as obtained fromOCC graph\n", + "Z_s = V_oc_ph/I_aph\n", + "R_a = 0.2 \t\t\t#armature effective resistance\n", + "X_s = math.sqrt( Z_s**2-R_a**2 )\n", + "\n", + "# Calculations and Results\n", + "#Part(i)\n", + "phi1 = math.acos(0.8)\t\t\t#lagging\n", + "E_ph1 = math.sqrt((V_ph*math.cos(phi1)+I_aph*R_a)**2+(V_ph*math.sin(phi1)+I_aph*X_s)**2)\n", + "regulation1 = 100*(E_ph1-V_ph)/V_ph\n", + "print \"i)Full-load percentage regulation at 0.8 pf lagging is %.2f percent\"%(regulation1)\n", + "\n", + "#Part(ii)\n", + "phi2 = math.acos(0.8)\t\t\t#leading\n", + "E_ph2 = math.sqrt((V_ph*math.cos(phi2)+I_aph*R_a)**2+(V_ph*math.sin(phi2)-I_aph*X_s)**2)\n", + "regulation2 = 100*(E_ph2-V_ph)/V_ph\n", + "print \"ii)Full-load percentage regulation at 0.8 pf leading is %.2f percent\"%(regulation2)\n", + "print 'Note that the answer mismatches because of calculation mistake done in the last step of part 1'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Full-load percentage regulation at 0.8 pf lagging is 73.86 percent\n", + "ii)Full-load percentage regulation at 0.8 pf leading is -9.29 percent\n", + "Note that the answer mismatches because of calculation mistake done in the last step of part 1\n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.29 Page no : 76" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 3300.\n", + "VA = 200.*10**3\n", + "R_a = 0.6\n", + "X_s = 6.\t\t\t#armature resistance and synchronous reactance\n", + "\n", + "# Calculations\n", + "I_L = VA/(math.sqrt(3)*V_L)\t\t\t#VA = math.sqrt(3)V_L*I_L\n", + "I_a = I_L\n", + "V_ph = V_L/math.sqrt(3)\n", + "phi = math.acos(0.8)\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_a*R_a)**2+(V_ph*math.sin(phi)+I_a*X_s)**2)\n", + "\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "\n", + "# Results\n", + "print 'Regulation at 0.8 lagging power factor is %.3f percent'%(regulation)\n", + "print ' Note : Regulation is positive for lagging power factor loads'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Regulation at 0.8 lagging power factor is 7.802 percent\n", + " Note : Regulation is positive for lagging power factor loads\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.30 Page no : 77" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 2300. \n", + "V_ph = V_L/math.sqrt(3)\n", + "f = 50.\n", + "R_a = 0.2 \t\t\t#armature resistance\n", + "I_sc = 150.\n", + "V_OC_line = 780. \n", + "V_OC_ph = V_OC_line/math.sqrt(3)\n", + "\n", + "Z_s = V_OC_ph/I_sc\n", + "X_s = math.sqrt(Z_s**2 - R_a**2)\n", + "I_aph = 25 \n", + "I_aFL = I_aph\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "phi = math.acos(0.8) \t\t\t#lag\n", + "E_ph = math.sqrt((V_ph*math.cos(phi)+I_aph*R_a)**2 +(V_ph*math.sin(phi)+ I_aph*X_s)**2)\n", + "regulation = 100*(E_ph-V_ph)/V_ph\n", + "print 'Voltage regulation at 0.8 pf lagging is %.3f percent'%(regulation)\n", + "\n", + "#part(ii)\n", + "phi2 = math.acos(0.8) \t\t\t#lead\n", + "E_ph2 = math.sqrt((V_ph*math.cos(phi2)+I_aph*R_a)**2 +(V_ph*math.sin(phi2)- I_aph*X_s)**2 )\n", + "regulation2 = 100*(E_ph2-V_ph)/V_ph\n", + "print 'Voltage regulation at 0.8 pf leading is %.3f percent'%(regulation2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage regulation at 0.8 pf lagging is 3.774 percent\n", + "Voltage regulation at 0.8 pf leading is -2.967 percent\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/DC_Machines_and_Synchronous_Machines/ch6.ipynb b/DC_Machines_and_Synchronous_Machines/ch6.ipynb new file mode 100755 index 00000000..b2228585 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/ch6.ipynb @@ -0,0 +1,2427 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:9f548e729a327e12aefb50cf84c5cae777df427713c1104c34d610a547e935f3" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 6 : Synchronization and Parallel Operation of Alternators" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + " \n", + "Example 6.2 Page no : 31" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "X_d = 0.7 \n", + "X_q = 0.4 \t\t\t#direct and quadrature axis synchronous reactance p.u.\n", + "R_a = 0\n", + "phi = math.acos(0.8) \t\t\t#Lag\n", + "\n", + "V_t = 1. \t\t\t#assumed rated terminal Voltage \n", + "I_a = 1. \t\t\t#Full-load armature current\n", + "\n", + "# Calculations\n", + "psi = math.atan( (V_t*math.sin(phi)+I_a*X_q)/(V_t*math.cos(phi)+I_a*R_a) )\n", + "delta = psi-phi\n", + "I_d = I_a*math.sin(psi)\n", + "I_q = I_a*math.cos(psi)\n", + "E_f = V_t*math.cos(delta)+I_d*X_d+I_q*R_a\n", + "\n", + "# Results\n", + "print 'Total e.m.f induced on open circuit is %.4f p.u.'%(E_f)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total e.m.f induced on open circuit is 1.5149 p.u.\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.3 Page no : 35" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import cmath\n", + "\n", + "#note that a new function p2z has been defined below for direct representation of complex numbers in polar form\n", + "def p2z(RRRR,Theeeta):\n", + " return RRRR*cmath.exp((math.pi*Theeeta/180.)*1j);\n", + "\n", + "# Variables\n", + "Z1 = complex(0,3) \t\t\t#impedance of alternator 1\n", + "Z2 = complex(0,4) \t\t\t#impedance of alternator 2\n", + "Z = 6. #load\n", + "\n", + "E1 = p2z(220,0) \t\t\t#induced emf vector on no load\n", + "E2 = p2z(220,10)\t\t\t#induced emf vector on no load\n", + "\n", + "# Calculations and Results\n", + "I1 = ((E1-E2)*Z+E1*Z2)/(Z*(Z1+Z2)+Z1*Z2)\n", + "I2 = ((E2-E1)*Z+E2*Z1)/(Z*(Z1+Z2)+Z1*Z2)\n", + "\n", + "phi1 = math.degrees(math.atan(I1.imag/I1.real)) \t\t\t#Phasemag returns the angle of complex number in degrees\n", + "phi2 = math.degrees(math.atan(I2.imag/I2.real)) \t\t\t#Phasemag returns the angle of complex number in degrees\n", + "\n", + "I = I1+I2\n", + "V = I*Z \t\t\t#Terminal voltage\n", + "print 'i) Terminal voltage is %.1f volts at %.2f degrees'%(abs(V),math.degrees(math.atan(V.imag/V.real)))\n", + "print 'ii) Currents are %.2f A at %.2f degrees and %.2f A at %.2f degrees \\\n", + "\\nTotal current is %.2f A at %.2f degrees '%(abs(I1),math.degrees(math.atan(I1.imag/I1.real)),\\\n", + " abs(I2),math.degrees(math.atan(I2.imag/I2.real)),\\\n", + " abs(I),math.degrees(math.atan(I.imag/I.real)))\n", + "\n", + "P1 = abs(V)*abs(I1)*math.cos(math.radians(phi1))\n", + "P2 = abs(V)*abs(I2)*math.cos(math.radians(phi2))\n", + "print 'iii)Power delivered is %.2f watts and %.2f watts'%(P1,P2)\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i) Terminal voltage is 210.7 volts at -11.66 degrees\n", + "ii) Currents are 14.91 A at -17.71 degrees and 20.36 A at -7.24 degrees \n", + "Total current is 35.12 A at -11.66 degrees \n", + "iii)Power delivered is 2992.46 watts and 4257.11 watts\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.4 Page no : 54" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_l = 10000.\n", + "V_ph = V_l/math.sqrt(3)\n", + "VA = 10.*10**6\n", + "I_FL = VA/(V_l*math.sqrt(3)) \t\t\t#Current at full laod\n", + "IX_s = (20./100)*V_ph \t\t\t#product of I and X_s\n", + "\n", + "# Calculations\n", + "X_s = IX_s/I_FL\n", + "N_s = 1500.\n", + "f = 50.\n", + "P = 120*f/N_s \t\t\t#poles\n", + "\n", + "delta_dash_mech = math.pi/180 \t\t\t#phase print lacement in degree mechanical\n", + "delta_dash_elec = delta_dash_mech*(P/2) \t\t\t#P/2 is pole pairs(and not poles)\n", + "E = V_ph \t\t\t#math.since alternator is on no-load\n", + "P_SY = delta_dash_elec*E**2/X_s \t\t\t#Synchronous Power\n", + "P_SY_3ph = P_SY*3 \t\t\t#For 3 phases\n", + "\n", + "# Results\n", + "print 'Synchronising Power of armature is %.3f kW.\\\n", + "\\nSynchronising Power for 3 phase is %.3f kW'%(P_SY*10**-3,P_SY_3ph*10**-3)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising Power of armature is 581.776 kW.\n", + "Synchronising Power for 3 phase is 1745.329 kW\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.5 Page no : 55" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import cmath\n", + "\n", + "#note that a new function p2z has been defined below for direct representation of complex numbers in polar form\n", + "\n", + "def p2z(RRRR,Theeeta):\n", + " return RRRR*cmath.exp(1j*math.pi*Theeeta/180.);\n", + "\n", + "# Variables\n", + "V_L = 6.6*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 3.*10**6\n", + "I_FL = VA/(V_L*math.sqrt(3)) \t\t\t#full load current \n", + "P = 8.\n", + "f = 50. \t\t\t#poles and frequency\n", + "\n", + "X_s = complex(0,2.9)\t\t\t#X_s = 2.9\n", + "delta_dash_mech = math.pi/180\n", + "delta_dash_elec = delta_dash_mech*(P/2) \t\t\t#P/2 is pole pairs(and not poles)\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "E = V_ph\n", + "P_SY = delta_dash_elec*E**2/abs(X_s) \t\t\t#Synchronous Power per phase\n", + "P_SY_3ph = P_SY*3 \t\t\t#For 3 phases\n", + "print 'i) Synchronising power at no load is %.3f kW'%(P_SY*10**-3)\n", + "print ' Total Synchronising power at no load is %.2f kW'%(P_SY_3ph*10**-3)\n", + "\n", + "N_s = 120*f/P \t\t\t#in rpm\n", + "n_s = (N_s)/60 \t\t\t#in rps\n", + "T_SY = P_SY_3ph/(2*math.pi*n_s)\n", + "print 'Synchronous torque per mechanical degree of phase print lacement is %.2f * 10**3 N-m'%(T_SY*10**-3)\n", + "\n", + "#part(ii)\n", + "phi = math.acos(math.radians(0.85))\n", + "I = p2z(I_FL,0)\n", + "V = p2z(V_ph,phi)\n", + "\n", + "E = V+I*X_s\n", + "#E leads I by phasemag(E). V leads I by phasemag(V)\n", + "\n", + "delta = (math.pi/180)* (math.atan(E.imag/E.real)-math.atan(V.imag/V.real) ) \t\t\t#power angle in radians\n", + "P_SY2 = abs(E)*abs(V)*math.cos(delta)*math.sin(delta_dash_elec)/abs(X_s)\n", + "\n", + "P_SY_total_2 = 3*P_SY2\n", + "#n_s = T_SY/(P_SY/(2*math.pi) ) \t\t\t#because T_SY = P_SY/(2*math.pi*n_s)\n", + "print 'ii)Total Synchronising power is %.0f kW'%(P_SY_total_2*10**-3)\n", + "\n", + "T_SY2 = P_SY_total_2/(2*math.pi*n_s)\n", + "print 'Synchronising torque is %.2f * 10**3 N-m'%(T_SY2/1000)\n", + "\n", + "# note : book answer is wrong.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i) Synchronising power at no load is 349.547 kW\n", + " Total Synchronising power at no load is 1048.64 kW\n", + "Synchronous torque per mechanical degree of phase print lacement is 13.35 * 10**3 N-m\n", + "ii)Total Synchronising power is 1074 kW\n", + "Synchronising torque is 13.68 * 10**3 N-m\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.6 Page no : 57" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import cmath\n", + "\n", + "#note that a new function p2z has been defined below for direct representation of complex numbers in polar form\n", + "def p2z(RRRR,Theeeta):\n", + " return RRRR*cmath.exp(1j*math.pi*Theeeta/180.)\n", + "\n", + "# Variables\n", + "V_l = 10.*10**3\n", + "V_ph = V_l/math.sqrt(3)\n", + "R_a = 0.4\n", + "Z = complex(R_a,6)\n", + "I_a = p2z(300,-math.acos(math.radians(0.8)))\n", + "E = V_ph+I_a*Z\n", + "\n", + "# Calculations\n", + "phi = math.acos(0.8)\n", + "alternator_op_ph = V_ph*abs(I_a)*math.cos(phi) \t\t\t#Power delivered to infinite bus per phase\n", + "\n", + "#Power deliered to the altrernator = Power delivewred to bus bar + I**2*R losses in armature\n", + "alternator_power = alternator_op_ph+ abs(I_a)**2*R_a\n", + "\n", + "#this power developed remains constant.change pf to 1 and calculate corresponding armature current\n", + "#alternator_power = V_ph*I_a1*math.cos(phi1)+I_a1**2*0.4\n", + "#solve the quadratic equation 0.4 I_a1**2+5773.50 I_a1- 1421640 = 0\n", + "I_a1 = (-1*V_ph+math.sqrt(V_ph**2-4*R_a*-1*alternator_power))/(2*R_a)\n", + "\n", + "#also as follows \n", + "E1 = V_ph+I_a1*Z\n", + "decrease = 100*(abs(E)-abs(E1))/abs(E)\n", + "\n", + "# Results\n", + "print 'Percentage decrease in induced e.m.f is %.1f percent'%(decrease)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Percentage decrease in induced e.m.f is 2.6 percent\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.7 Page no : 58" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Line PQ for Altermnator 1 and PR for alternaator 2.AB is at frequency x from P where total load is 3000 kW\n", + "\n", + "# Variables\n", + "QC = 2000.\n", + "PS = 2.5\n", + "#PC = x\n", + "TR = 2000.\n", + "PT = 2.\n", + "\n", + "# Calculations and Results\n", + "#using similarity of triangles PAC and PQS\n", + "AC_by_PC = (QC/PS)\t\t\t# because (AC/QC) = (PC/PS)\n", + "#using similarity of triangles PCB and PTR\n", + "CB_by_PC = (TR/PT) \t\t\t# because (CB/TR) = (PC/PT)\n", + "\n", + "AC_by_x = AC_by_PC \t\t\t#which implies AC = 12.5*x\n", + "CB_by_x = CB_by_PC \t\t\t#which implies CB = 16.67*x\n", + "\n", + "AC_plus_CB = 3000. \t\t\t#total load at the frequency at P is 30 kW\n", + "x = AC_plus_CB/(AC_by_x + CB_by_x)\n", + "AC = AC_by_x * x\n", + "CB = CB_by_x * x \n", + "frequency = 50-x\n", + "print 'Loads shared by alternator 1 and 2 are %.2f kW and %.2f kW respectively'%(AC,CB)\n", + "\n", + "#construction for max load: RT is extended to cut PQ at X.\n", + "QS = 2000.\n", + "RT = 2000. \t\t\t#see figure\n", + "XT = QS*(PT/PS)\n", + "RX = RT+XT \t\t\t#maximum load\n", + "\n", + "print 'Maximum load is %.0f kW'%(RX)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loads shared by alternator 1 and 2 are 1333.33 kW and 1666.67 kW respectively\n", + "Maximum load is 3600 kW\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.8 Page no : 60" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "P_out = 1500.*10**3\n", + "V_L = 11000.\n", + "phi = math.acos(0.8)\n", + "I_L = P_out/(math.sqrt(3)*V_L*math.cos(phi))\n", + "\n", + "I_L_actv = I_L*math.cos(phi) \t\t\t#wattful or active component of current\n", + "I_L_reactive = I_L*math.sin(phi) \t\t\t#wattless or reactive component of current\n", + "\n", + "# Calculations and Results\n", + "I_each = I_L/2 \t\t\t#in identical conditions\n", + "I_arm1 = 45. \t\t\t#given\n", + "I_1_reactive = math.sqrt(I_arm1**2-39.364**2 ) \t\t\t#from the power triangle \n", + "I_2_reactive = 59.046-21.80\n", + "I_a_2 = math.sqrt( 39.364**2 + I_2_reactive**2 ) \t\t\t#required armature current of 2nd alternator\n", + "print 'Required armature current of second alternator is %.4f A'%(I_a_2)\n", + "#power factors of 2 machines\n", + "cos_phi1 = 39.364/45 \n", + "cos_phi2 = 39.364/54.1921\n", + "\n", + "print 'Power factors are %.4f lagging and %.4f lagging'%(cos_phi1,cos_phi2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required armature current of second alternator is 54.1921 A\n", + "Power factors are 0.8748 lagging and 0.7264 lagging\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.9 Page no : 61" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Line AB for Altermnator 1 and AC for alternator 2.AF is at frequency x measured from A where total load is 3000 kW\n", + "# Variables\n", + "BO = 2000.\n", + "AO = 5.\t\t\t#AF = x\n", + "DC = 2000.\n", + "AD = 3.\n", + "#AF = x\n", + "\n", + "# Calculations\n", + "#using similarity of triangles AEF and ABO\n", + "EF_by_AF = (BO/AO)\t\t\t# because (EF/BO) = (AF/AO)\n", + "#using similarity of triangles AFG and ADC\n", + "FG_by_AF = (DC/AD) \t\t\t#because (FG/DC) = (AF/AD)\n", + "\n", + "EF_by_x = EF_by_AF \t\t\t#which implies EF = 400*x\n", + "FG_by_x = FG_by_AF \t\t\t#which implies FG = 666.67*x\n", + "\n", + "EF_plus_FG = 3000 \t\t\t#total load at the frequency at P is 3000 kW\n", + "x = EF_plus_FG/(EF_by_x + FG_by_x)\n", + "EF = (BO/AO)*x\n", + "FG = (DC/AD)*x \n", + "\n", + "# Results\n", + "print 'Loads shared by machine 1 and 2 are %.0f kW and %.0f kW respectively'%(EF,FG)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loads shared by machine 1 and 2 are 1125 kW and 1875 kW respectively\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.10 Page no : 63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import cmath\n", + "\n", + "#note that a new function p2z has been defined below for direct representation of complex numbers in polar form\n", + "\n", + "def p2z(RRRR,Theeeta):\n", + " return RRRR*cmath.exp(1j*math.pi*Theeeta/180.);\n", + "\n", + "# Variables\n", + "V_l = 6000.\n", + "V_ph = V_l/math.sqrt(3)\n", + "VA = 2000.*10**3\n", + "I_FL = VA/(V_l*math.sqrt(3))\n", + "X_s = complex(0,6) \t\t\t#synchronous reactance\n", + "P = 8.\n", + "f = 50.\n", + "\n", + "delta_mech = math.pi/180 \t\t\t#phase print lacemant in degree mechanical \n", + "#phase print lacemant in degree electrical\n", + "delta_elec = delta_mech*(P/2) \t\t\t#P/2 is pole pairs(and not poles)\n", + "\n", + "phi = math.acos(math.radians(0.8))\n", + "V = p2z(V_ph,phi)\n", + "E = V+I_FL*X_s\n", + "#E leads I by phasemag(E). V leads I by phasemag(V)\n", + "\n", + "# Calculations and Results\n", + "delta = (math.pi/180)* (math.atan(E.imag/E.real)-(math.atan(V.imag/V.real ) ) ) \t\t\t#power angle in radians\n", + "P_SY = abs(E)*abs(V)*math.cos(delta)*math.sin(delta_elec)/abs(X_s) \t\t\t#Synchronising power\n", + "P_SY_total = 3*P_SY \t\t\t#totla Synchronising power \n", + "print 'Total Synchronising power is %.3f kW'%(10**-3*P_SY_total)\n", + "\n", + "N_s = 120*f/P \t\t\t#in rpm\n", + "n_s = (N_s)/60 \t\t\t#in rps\n", + "T_SY = P_SY_total/(2*math.pi*n_s)\n", + "print 'Synchronising torque is %.0f N-m'%(T_SY)\n", + "\n", + "# note : book answer it seems wrong." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total Synchronising power is 444.753 kW\n", + "Synchronising torque is 5663 N-m\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.11 Page no : 64" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import cmath\n", + "\n", + "#note that a new function p2z has been defined below for direct representation of complex numbers in polar form\n", + "def p2z(RRRR,Theeeta):\n", + " return RRRR*cmath.exp(1j*math.pi*Theeeta/180.);\n", + "\n", + "# Variables\n", + "V_l = 3300.\n", + "V_ph = V_l/math.sqrt(3)\n", + "VA = 3*10.**6\n", + "I_FL = VA/(V_l*math.sqrt(3))\n", + "IX_s = (25./100)*V_ph \t\t\t#product of I and X_s\n", + "X_s = complex(0,IX_s/I_FL) \t\t\t#synchronous reactance\n", + "N_s = 1000. \t\t\t#in rpm\n", + "P = 6.\n", + "f = 50.\n", + "\n", + "# Calculations and Results\n", + "delta_dash_mech = math.pi/180\n", + "delta_dash_elec = delta_dash_mech*(P/2) \t\t\t#P/2 is pole pairs(and not poles)\n", + "\n", + "I = I_FL\n", + "phi = math.acos(math.radians(0.8))\n", + "V = p2z(V_ph,phi)\n", + "E = V+I*X_s\n", + "#E leads I by phasemag(E). V leads I by phasemag(V)\n", + "\n", + "delta = (math.pi/180)* (math.atan(E.imag/E.real)-math.atan(V.imag/V.real) ) \t\t\t#power angle in radians\n", + "P_SY = abs(E)*abs(V)*math.cos(delta)*math.sin(delta_dash_elec)/abs(X_s) \t\t\t#Synchronising power per phase\n", + "print 'Synchronising power is %.3f kW'%(10**-3*P_SY)\n", + "P_SY_total = 3*P_SY \t\t\t#Total Synchronising power\n", + "\n", + "N_s = 120*f/P \t\t\t#in rpm\n", + "n_s = (N_s)/60 \t\t\t#in rps\n", + "T_SY = P_SY_total/(2*math.pi*n_s)\n", + "print 'Synchronising torque is %.0f N-m'%(T_SY)\n", + "\n", + "print 'Answer mismatches due to approximation'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power is 217.160 kW\n", + "Synchronising torque is 6221 N-m\n", + "Answer mismatches due to approximation\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.12 Page no : 65" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_l = 3300.\n", + "V_ph = V_l/math.sqrt(3)\n", + "VA = 3*10.**6\n", + "I_FL = VA/(V_l*math.sqrt(3))\n", + "IX_s = (20./100)*V_ph \t\t\t#product of I and X_s\n", + "X_s = complex(0,IX_s/I_FL) \t\t\t#synchronous reactance\n", + "N_s = 1000.\n", + "P = 6.\n", + "f = 50.\n", + "\n", + "delta_dash_mech = math.pi/180 \t\t\t#phase print lacement in degree mechanical\n", + "#phase print lacement in degree electrical\n", + "delta_dash_elec = delta_dash_mech*(P/2) \t\t\t#P/2 is pole pairs(and not poles)\n", + "\n", + "# Calculations and Results\n", + "E = V_ph\n", + "Z_s = X_s \t\t\t#math.since R = 0\n", + "P_SY = abs(E)*abs(V_ph)*delta_dash_elec/abs(Z_s) \t\t\t#Synchronising power per phase\n", + "print 'Synchronising power is %.3f kW'%(10**-3*P_SY)\n", + "P_SY_total = 3*P_SY \t\t\t#Total Synchronising power\n", + "print '3 phase Synchronising power is %.3f kW'%(10**-3*P_SY_total)\n", + "\n", + "N_s = 120*f/P \t\t\t#in rpm\n", + "n_s = (N_s)/60 \t\t\t#in rps\n", + "T_SY = P_SY_total/(2*math.pi*n_s)\n", + "print 'Synchronising torque is %.0f N-m'%(T_SY)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power is 261.799 kW\n", + "3 phase Synchronising power is 785.398 kW\n", + "Synchronising torque is 7500 N-m\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.13 Page no : 66" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 11.*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 700.*10**3\n", + "I_FL = VA/(math.sqrt(3)*V_L) \t\t\t#full load current\n", + "IR_a = (1.5/100)*V_ph \t\t\t#product of I and R_a\n", + "R_a = IR_a/I_FL\n", + "IX_s = (14./100)*V_ph \t\t\t# product of I and X_s\n", + "X_s = IX_s/I_FL \t\t\t#synchronous reactance\n", + "\n", + "# Calculations\n", + "#at full load and 0.8 pf\n", + "I = I_FL\n", + "phi = math.acos(0.8)\n", + "V_ph = complex(V_ph*math.cos(phi),V_ph*math.sin(phi)) \t\t\t#just introduced the angle\n", + "E_ph = math.sqrt( (abs(V_ph)*math.cos(phi)+ IR_a)**2+ (abs(V_ph)*math.sin(phi)+ IX_s)**2 )\n", + "\n", + "Poles = 4.\n", + "f = 50. \t\t\t#poles and frequency\n", + "delta = math.asin( (abs(V_ph)*math.sin(phi)+IX_s)/E_ph) -phi\n", + "delta_dash_mech = (math.pi/180) \t\t\t#print lacement in degree mechanical\n", + "\t\t\t#print lacement in degree electrical\n", + "delta_dash_elec = delta_dash_mech*(Poles/2)\n", + "P_SY = abs(E_ph)*abs(V_ph)*math.cos(delta)*math.sin(delta_dash_elec)/X_s \t\t\t#Synchronising power per phase \n", + "P_SY_total = 3*P_SY \t\t\t#total Synchronising power\n", + "\n", + "ns = 120*f/(60*Poles) \t\t\t#in r.p.s\n", + "T_SY = P_SY_total/(2*math.pi*ns) \t\t\t#Synchronising torque \n", + "\n", + "# Results\n", + "print 'Synchronising power is %.2fkW'%(P_SY_total/1000)\n", + "print 'Synchronising torque is %.2f N-m'%(T_SY)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power is 191.25kW\n", + "Synchronising torque is 1217.53 N-m\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.14 Page no : 68" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_l = 9.*10**3\n", + "V_ph = V_l/math.sqrt(3)\n", + "VA = 5.5*10**6\n", + "I_FL = VA/(V_l*math.sqrt(3))\n", + "IX_s = (25./100)*V_ph \t\t\t#product of I and X_s\n", + "X_s = complex(0,IX_s/I_FL) \t\t\t#synchronous reactance\n", + "N_s = 1500. \t\t\t#in rpm\n", + "n_s = N_s/60 \t\t\t#in rps\n", + "f = 50.\n", + "P = 120.*f/N_s \t\t\t#frequency and pole\n", + "\n", + "# Calculations\n", + "delta_dash_mech = math.pi/180 \t\t\t#print lacemnt in degree mechanical \n", + "#print lacemnt in degree electrical\n", + "delta_dash_elec = delta_dash_mech*(P/2) \t\t\t#P/2 is pole pairs(and not poles)\n", + "\n", + "E = V_ph\n", + "P_SY = abs(E)*abs(V_ph)*delta_dash_elec/abs(X_s) \t\t\t#Synchronising power per phase\n", + "P_SY_total = 3*P_SY \t\t\t#Total Synchronising power\n", + "\n", + "T_SY = P_SY_total/(2*math.pi*n_s)\n", + "\n", + "# Results\n", + "print 'Synchronising torque is %.2f N-m'%(T_SY)\n", + "print 'Answer mismatches due to approximation'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising torque is 4888.89 N-m\n", + "Answer mismatches due to approximation\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.15 Page no : 69" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 6.*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 2000.*10**3\n", + "I_FL = VA/(math.sqrt(3)*V_L) \n", + "I = I_FL\n", + "\n", + "# Calculations\n", + "X_s = 1.2\n", + "R_a = 0.01 \t\t\t#both per unit\n", + "IR_a = (1/100)*V_ph \t\t\t#product of I and R_a\n", + "R_a = IR_a/I_FL\n", + "IX_s = (120/100)*V_ph \t\t\t#product of I and X_s\n", + "#IX_s = (12/100)*V_ph \t\t\t# this is the mistake made in the textbook\n", + "X_s = IX_s/I_FL\n", + "\n", + "#at full load and 0.8 pf\n", + "phi = math.acos(0.8)\n", + "#V_ph = complex(V_ph*math.cos(phi)V_ph*math.sin(phi)) \t\t\t#just introduced the angle\n", + "E_ph = math.sqrt( (abs(V_ph)*math.cos(phi)+ IR_a)**2+ (abs(V_ph)*math.sin(phi)+ IX_s)**2 )\n", + "Poles = 8\n", + "f = 50\n", + "\n", + "delta = math.asin( (abs(V_ph)*math.sin(phi)+IX_s)/E_ph) -phi\n", + "delta_dash_mech = (math.pi/180) \t\t\t#print lacemnt in degree mechanical \n", + "#print lacemnt in degree electrical\n", + "delta_dash_elec = delta_dash_mech*(Poles/2)\n", + "P_SY = abs(E_ph)*abs(V_ph)*math.cos(delta)*math.sin(delta_dash_elec)/X_s \t\t\t#Synchronising power per phase\n", + "P_SY_total = 3*P_SY \t\t\t#total Synchronising power\n", + "\n", + "ns = 120*f/(60*Poles) \t\t\t#in r.p.s\n", + "T_SY = P_SY_total/(2*math.pi*ns) \t\t\t#Synchronising torque \n", + "\n", + "# Results\n", + "print 'Synchronising power is %.2f kW'%(P_SY_total/1000)\n", + "print 'Synchronising torque is %.2f N-m'%(T_SY)\n", + "\n", + "print 'Note that answer obtained doesnt match with textbook due to the following reasons: \\\n", + "\\niIX_s is considered wrong in textbook.It should have been 4156.92instead of 415.692 To verify this use commented statement of IX_s line 13and notice that it matches with textbook ans then' \n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power is 223.22 kW\n", + "Synchronising torque is 2960.56 N-m\n", + "Note that answer obtained doesnt match with textbook due to the following reasons: \n", + "iIX_s is considered wrong in textbook.It should have been 4156.92instead of 415.692 To verify this use commented statement of IX_s line 13and notice that it matches with textbook ans then\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.16 Page no : 71" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "E = 11.*10**3/math.sqrt(3)\n", + "I_sc = 1000.\n", + "Pole = 2.\n", + "f = 50.\n", + "delta_dash_mech = 1*math.pi/180 \t\t\t#print lacemnt in degree mechanical \n", + "\n", + "# Calculations\n", + "#print lacemnt in degree electrical \n", + "delta_dash_elec = delta_dash_mech*(Pole/2)\n", + "P_SY = E*I_sc*delta_dash_mech \t\t\t#Synchronising power per phase\n", + "P_SY_total = P_SY*3 \t\t\t#total Synchronising power\n", + "\n", + "ns = 120*f/(60*Pole) \t\t\t#in r.p.s\n", + "T_SY = P_SY_total/(2*math.pi*ns) \t\t\t#Synchronising torque \n", + "\n", + "# Results\n", + "print 'Synchronising power is %.2f kW'%(P_SY_total/1000)\n", + "print 'Synchronising torque is %.2f N-m'%(T_SY)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power is 332.53 kW\n", + "Synchronising torque is 1058.48 N-m\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.17 Page no : 72" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Line PQ for Altermnator 1 and PR for alternaator 2.AB is at frequency x from P where total load is 30 MW\n", + "# Variables\n", + "QT = 25.\n", + "PT = 2.\n", + "#PC = x\n", + "SR = 25.\n", + "PS = 1.5\n", + "\n", + "# Calculations\n", + "#using similarity of triangles PAC and PQT\n", + "AC_by_PC = (QT/PT)\t\t\t# because (AC/QT) = (PC/PT)\n", + "#using similarity of triangles PCB and PSR\n", + "CB_by_PC = (SR/PS)\n", + "\n", + "AC_by_x = AC_by_PC \t\t\t#which implies AC = 12.5*x\n", + "CB_by_x = CB_by_PC \t\t\t#which implies CB = 16.67*x\n", + "\n", + "AC_plus_CB = 30 \t\t\t#total load at the frequency at P is 30 MW\n", + "x = AC_plus_CB/(AC_by_x + CB_by_x)\n", + "AC = 12.5*x\n", + "CB = 16.67*x \n", + "frequency = 50-x\n", + "\n", + "# Results\n", + "print 'Loads shared by alternator 1 and 2 are %.2f MW and %.2f MW respectively'%(AC,CB)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loads shared by alternator 1 and 2 are 12.86 MW and 17.15 MW respectively\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.18 Page no : 73" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import cmath\n", + "\n", + "#note that a new function p2z has been defined below for direct representation of complex numbers in polar form\n", + "def p2z(RRRR,Theeeta):\n", + " return RRRR*cmath.exp(1j*math.pi*Theeeta/180.);\n", + "\n", + "# Variables\n", + "load_total = 1600.*10**3\n", + "pf = 1/math.sqrt(2) \t\t\t#lag\n", + "V_L = 6600.\n", + "\n", + "# Calculations\n", + "I_L = p2z(load_total/(math.sqrt(3)*V_L*pf),-1*math.acos(math.radians(pf)) )\n", + "I_1 = p2z(90,-1*math.acos(math.radians(0.8)))\n", + "I_2 = I_L-I_1\n", + "phi = abs(math.atan(I_2.imag/I_2.real))\n", + "I_a = abs(I_2)\n", + "R_a = 1.05\n", + "X_s = 5 \t\t\t#resistance and synchronous reactance per phase\n", + "V_ph = V_L/math.sqrt(3)\n", + "E_ph = math.sqrt( (V_ph*math.cos(phi)+I_a*R_a )**2 + ( V_ph*math.sin(phi)+I_a*X_s )**2 )\n", + "E_line = math.sqrt(3)*E_ph\n", + "\n", + "# Results\n", + "print 'Excitation of second alternator is %.2f V '%(E_line)\n", + "print ' The corresponding field current from the graph is about 310 A'\n", + "print 'Note: The answer obtained will differ from textbook answer because of higher degree of accuracy while storing I_2 and the improper rounding off of I_2 in the textbook'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Excitation of second alternator is 6884.65 V \n", + " The corresponding field current from the graph is about 310 A\n", + "Note: The answer obtained will differ from textbook answer because of higher degree of accuracy while storing I_2 and the improper rounding off of I_2 in the textbook\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.19 Page no : 75" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 10.*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 5.*10**6\n", + "I_FL = VA/(math.sqrt(3)*V_L) \t\t\t#full-load current\n", + "IX_s = (20./100)*V_ph \t\t\t#product of I and X_s\n", + "X_s = IX_s/I_FL \t\t\t#synchronous reactance\n", + "P = 4.\n", + "\n", + "# Calculations\n", + "delta_dash_mech = 1*(math.pi/180) \t\t\t#print lacement in degree mechanical \n", + "#print lacement in degree electrical\n", + "delta_dash_elec = delta_dash_mech*(P/2)\n", + "E = V_ph \t\t\t#at no load\n", + "P_SY = delta_dash_elec*E**2/X_s \t\t\t#Synchronising power per phase\n", + "P_SY_total = P_SY*3 \t\t\t#Total Synchronising power\n", + "\n", + "# Results\n", + "print 'Synchronising power per phase is %.2fkW \\\n", + "\\nTotal Synchronising power is %.2fkW '%(P_SY/1000,P_SY_total/1000)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power per phase is 290.89kW \n", + "Total Synchronising power is 872.66kW \n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.20 Page no : 76" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Power_total = 1.414 \t\t\t#per unit\n", + "V_L = 1. \t\t\t#per unit\n", + "phi_t = math.acos(0.707)\n", + "I_L_T = Power_total/(math.sqrt(3)*V_L*math.cos(phi_t)) \t\t\t#Total current\n", + "\n", + "# Calculations\n", + "#Current supplied by each alternator\n", + "I_1 = I_L_T/2\n", + "I_2 = I_1\n", + "V_ph = V_L/math.sqrt(3)\n", + "\n", + "phi = math.acos(0.707)\n", + "R_a = 0\n", + "X_s = 0.6 \t\t\t#resistacne and synchronous reactance\n", + "E_ph = math.sqrt( (V_ph*math.cos(phi)+ I_1*R_a)**2 + (V_ph*math.sin(phi)+I_1*X_s)**2 )\n", + "delta = math.atan((I_1*X_s+V_ph*math.sin(phi)) / (V_ph*math.cos(phi))) - phi \t\t\t#power angle\n", + "\n", + "# Results\n", + "print 'EMF is %.4f p.u. and power angle is %.2f degrees '%(E_ph,delta*180/math.pi)\n", + "print 'Following assumptions were made :'\n", + "print '1.Terminal or bus bar voltage at ppoint of connection is constant'\n", + "print '2.The alternators are identical and are initially equally excited'\n", + "print '3.The power supplied by prime movers is adjusted so that each machine carries half the load represented by external impedance Z = R+ j 2pifL %( where R and L are constant'\n", + "print '4.The stator resistance is negligible'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "EMF is 0.8580 p.u. and power angle is 16.58 degrees \n", + "Following assumptions were made :\n", + "1.Terminal or bus bar voltage at ppoint of connection is constant\n", + "2.The alternators are identical and are initially equally excited\n", + "3.The power supplied by prime movers is adjusted so that each machine carries half the load represented by external impedance Z = R+ j 2pifL %( where R and L are constant\n", + "4.The stator resistance is negligible\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.21 Page no : 77" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_l = 480.\n", + "X_d = 0.1\n", + "X_q = 0.075\n", + "R_a = 0. \t\t\t#armature resistance and synchronous reactance of direct quadrature axis\n", + "I_l = 1200.\n", + "I_ph = I_l/math.sqrt(3)\n", + "V_ph = V_l\n", + "V_t = V_l\n", + "I_a = I_ph\n", + "\n", + "# Calculations\n", + "phi = math.acos(0.8)\n", + "psi = math.atan( (V_t*math.sin(phi)+I_a*X_q)/(V_t*math.cos(phi)+I_a*R_a) )\n", + "delta = psi-phi \n", + "\n", + "I_d = I_a*math.sin(psi)\n", + "I_q = I_a*math.cos(psi)\n", + "E_f = V_t*math.cos(delta)+I_d*X_d+I_q*R_a\n", + "\n", + "# Results\n", + "print 'Excitation e.m.f is %.f V '%(E_f)\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Excitation e.m.f is 524 V \n" + ] + } + ], + "prompt_number": 37 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.22 Page no : 78" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "VA = 3.5*10**6\n", + "P = 32. \t\t\t#Poles\n", + "Power = 2.5*10**6 \t\t\t#In watts\n", + "V_l = 6.6*10**3\n", + "phi = math.acos(0.8)\n", + "I_l = Power/(V_l*math.cos(phi)*math.sqrt(3))\n", + "X_d = 9.6\n", + "X_q = 6.\n", + "R_a = 0. \t\t\t#armature resistance and synchronous reactance of direct quadrature axis\n", + "\n", + "# Calculations\n", + "V_t = V_l/math.sqrt(3)\n", + "psi = math.atan( (V_t*math.sin(phi)+I_l*X_q)/(V_t*math.cos(phi)+I_l*R_a) )\n", + "delta = psi-phi\n", + "I_s = I_l\n", + "I_d = I_s*math.sin(psi)\n", + "I_q = I_s*math.cos(psi)\n", + "E_f = V_t*math.cos(delta)+I_d*X_d+I_q*R_a\n", + "regulation = 100*(E_f-V_t)/V_t\n", + "\n", + "# Results\n", + "print 'percentage regulation is %.2f percent'%(regulation)\n", + "print 'Excitation emf = %.0f V'%(E_f)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "percentage regulation is 50.85 percent\n", + "Excitation emf = 5748 V\n" + ] + } + ], + "prompt_number": 38 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.23 Page no : 79" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "X_d = 7.6\n", + "X_q = 4.5\n", + "R_a = 0.15 \t\t\t#armature resistance and synchronous reactance of directquadrature \n", + "axisV_l = 13.8*10**3\n", + "V_l = 13.8*10**3\n", + "V_t = V_l/math.sqrt(3)\n", + "phi = math.acos(0.8)\n", + "VA = 25*10**6\n", + "I_a = VA/(math.sqrt(3)*V_l)\n", + "psi = math.atan( (V_t*math.cos(phi)+I_a*X_q)/(V_t*math.sin(phi)+I_a*R_a) )\n", + "\n", + "# Calculations\n", + "delta = psi-phi\n", + "I_s = I_a\n", + "I_d = I_s*math.sin(psi)\n", + "I_q = I_s*math.cos(psi)\n", + "\n", + "E_f = V_t*math.cos(delta)+I_d*X_d+I_q*R_a\n", + "regulation = 100*(E_f-V_t)/V_t\n", + "\n", + "# Results\n", + "print 'percentage regulation is %.2f percent'%(regulation)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "percentage regulation is 79.30 percent\n" + ] + } + ], + "prompt_number": 39 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.24 Page no : 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "X_d = 1.\n", + "X_q = 0.6\n", + "R_a = 0. \t\t\t#armature resistance and synchronous reactance of direct quadrature axis\n", + "phi = math.acos(0.8) \t\t\t#lag\n", + "V_t = 1.\n", + "I_a = 1. \t\t\t#full load\n", + "psi = math.atan( (V_t*math.sin(phi)+I_a*X_q)/(V_t*math.cos(phi)+I_a*R_a) )\n", + "\n", + "# Calculations\n", + "delta = psi-phi\n", + "I_s = I_a\n", + "I_d = I_a*math.sin(psi)\n", + "I_q = I_a*math.cos(psi)\n", + "\n", + "E_f = V_t*math.cos(delta)+I_d*X_d+I_q*R_a\n", + "regulation = 100*(E_f-V_t)/V_t\n", + "\n", + "# Results\n", + "print 'percentage regulation is %.2f percent'%(regulation)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "percentage regulation is 77.50 percent\n" + ] + } + ], + "prompt_number": 40 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.25 Page no : 81" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "I_a = 10.\n", + "phi = 20. \t\t\t#lag and degrees\n", + "V_t = 400.\n", + "X_d = 10.\n", + "X_q = 6.5\n", + "R_a = 0. \t\t\t#armature resistance and synchronous reactance of direct quadrature axis\n", + "\n", + "# Calculations\n", + "psi = math.atan((V_t*math.sin(math.radians(phi))+I_a*X_q)/(V_t*math.cos(math.radians(phi))+I_a*R_a))\n", + "delta = math.degrees(psi)-phi\n", + "I_d = math.degrees(I_a*math.sin(math.radians(psi)))\n", + "I_q = (I_a*math.cos(psi))\n", + "\n", + "# Results\n", + "print 'Load angle is %.2f degrees '%(delta)\n", + "print 'I_d and I_q are %.4f A and %.4f A respectively '%(I_d,I_q )\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Load angle is 8.23 degrees \n", + "I_d and I_q are 4.9272 A and 8.8105 A respectively \n" + ] + } + ], + "prompt_number": 53 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.26 Page no : 81" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "X_d = 0.8\n", + "X_q = 0.5\n", + "R_a = 0.02 \t\t\t#armature resistance and synchronous reactance of direct quadrature axis\n", + "\n", + "\t\t\t#case(i) lag\n", + "phi = math.acos(0.8)\n", + "V_t = 1\n", + "I_a = 1\t\t\t#full-load\n", + "psi = math.atan( (V_t*math.sin(phi)+I_a*X_q)/(V_t*math.cos(phi)+I_a*R_a) )\n", + "delta = psi-phi\n", + "\n", + "I_d = I_a*math.sin(psi)\n", + "I_q = I_a*math.cos(psi)\n", + "\n", + "E_f = V_t*math.cos(delta)+I_d*X_d+I_q*R_a\n", + "regulation = 100*(E_f-V_t)/V_t\n", + "print 'percentage regulation at 0.8 pf lag is %.2f percent'%(regulation)\n", + "\n", + "\t\t\t#case(ii) lead\n", + "phi2 = -1*math.acos(0.8) \t\t\t#minus sign because of leading pf\n", + "psi2 = math.atan( (V_t*math.sin(phi2)+I_a*X_q)/(V_t*math.cos(phi2)+I_a*R_a) )\n", + "delta2 = psi2-phi2\n", + "\n", + "I_d2 = I_a*math.sin(psi2)\n", + "I_q2 = I_a*math.cos(psi2)\n", + "\n", + "E_f2 = V_t*math.cos(delta2)+I_d2*X_d+I_q2*R_a\n", + "regulation2 = 100*(E_f2-V_t)/V_t\n", + "print 'percentage regulation at 0.8 pf lead is %.f percent'%(regulation2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "percentage regulation at 0.8 pf lag is 61.25 percent\n", + "percentage regulation at 0.8 pf lead is -21 percent\n" + ] + } + ], + "prompt_number": 55 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.27 Page no : 83" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import *\n", + "\n", + "# Variables\n", + "kW = array([800,500,1000,600])\n", + "cosphi = array([1,0.9,0.8,0.9])\n", + "tanphi = tan(arccos(cosphi))\n", + "kVAR = kW*tanphi\n", + "\n", + "# Calculations\n", + "kW_total = kW[0]+kW[1]+kW[2]+kW[3]\n", + "kVAR_total = kVAR[0]+kVAR[1]+kVAR[2]+-1*kVAR[3] \t\t\t#4th case is leading \n", + "\n", + "phi_c = math.atan(kVAR_total/kW_total) \t\t\t#total power factor angle\n", + "phi_1 = math.acos(0.95)\t\t\t#pf of machine 1\n", + "kW_1 = 1000 \t\t\t#active component of machine 1\n", + "kVAR_1 = kW_1*math.tan(phi_1) \t\t\t#reactive component of machine 1\n", + "kW_2 = kW_total - kW_1 \t\t\t#active component of machine 1\n", + "kVAR_2 = kVAR_total-kVAR_1 \t\t\t#reactive component of machine 2\n", + "\n", + "phi_2 = math.atan(kVAR_2/kW_2) \n", + "pf_2 = math.cos(phi_2) \t\t\t#power factor of machine 2\n", + "\n", + "# Results\n", + "print 'Output of second alternator = %.0f kW'%(kW_2)\n", + "print 'power factor of machine 2 = %.2f and lagging'%(pf_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Output of second alternator = 1900 kW\n", + "power factor of machine 2 = 0.98 and lagging\n" + ] + } + ], + "prompt_number": 56 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.28 Page no : 84" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import *\n", + "\n", + "# Variables\n", + "kW = array([250,300,150])\n", + "cosphi = array([0.9,0.75,0.8]) \t\t\t#all lagging\n", + "tanphi = tan(arccos(cosphi))\n", + "kVAR = kW*tanphi\n", + "\n", + "# Calculations\n", + "kW_total = kW[0]+kW[1]+kW[2]\n", + "kVAR_total = kVAR[0]+kVAR[1]+kVAR[2] \n", + "\n", + "phi_1 = math.acos(0.8)\t\t\t#pf of machine 1\n", + "kW_1 = 100 \t\t\t#active component of machine 1\n", + "kVAR_1 = kW_1*math.tan(phi_1) \t\t\t#reactive component of machine 1\n", + "kW_2 = kW_total - kW_1 \t\t\t#active component of machine 1\n", + "kVAR_2 = kVAR_total-kVAR_1 \t\t\t#reactive component of machine 2\n", + "phi_2 = math.atan(kVAR_2/kW_2) \n", + "pf_2 = math.cos(phi_2) \t\t\t#power factor of machine 2\n", + "\n", + "# Results\n", + "print 'Output of second alternator = %.0f kW'%(kW_2)\n", + "print 'power factor of machine 2 = %.4f and lagging'%(pf_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Output of second alternator = 600 kW\n", + "power factor of machine 2 = 0.8172 and lagging\n" + ] + } + ], + "prompt_number": 57 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.29 Page no : 85" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 6.6*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "V_t = V_ph\n", + "X_d = 9.6\n", + "X_q = 6.\n", + "R_a = 0. \t\t\t#armature resistance and synchronous reactance of direct quadrature axis\n", + "VA = 3.5*10**6\n", + "I_L = VA/(math.sqrt(3)*V_L)\n", + "\n", + "# Calculations\n", + "P = 2.5*10**6\n", + "phi = math.acos(0.8)\n", + "I_a = P/(math.sqrt(3)*V_L*math.cos(phi))\n", + "psi = math.atan( (V_t*math.sin(phi)+ I_a*X_q)/(V_t*math.cos(phi)+ I_a*R_a) )\n", + "\n", + "delta = psi-phi\n", + "I_d = I_a*math.sin(psi)\n", + "I_q = I_a*math.cos(phi)\n", + "\n", + "E_f = V_t*math.cos(delta)+I_d*X_d+I_q*R_a\n", + "regulation = 100*(E_f-V_t)/V_t\n", + "P_max = (V_ph**2/2)*((X_d-X_q)/(X_d*X_q))*(math.sin(2*delta))\n", + "\n", + "# Results\n", + "print 'percentage voltage regulation is %.2f percent'%(regulation)\n", + "print 'Power under open circuit is %.1f kW per phase'%(P_max/1000)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "percentage voltage regulation is 50.85 percent\n", + "Power under open circuit is 231.1 kW per phase\n" + ] + } + ], + "prompt_number": 58 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.30 Page no : 86" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 3.3*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 3.*10**6\n", + "I_FL = VA/(math.sqrt(3)*V_L)\n", + "IX_s = (25./100)*V_ph \t\t\t#product of I and X_s\n", + "X_s = complex(0,IX_s/I_FL)\n", + "N_s = 1000 \t\t\t#in r.p.m\n", + "\n", + "\n", + "# Calculations\n", + "Poles = 6.\n", + "f = 50.\n", + "delta_dash_mech = (math.pi/180) \t\t\t#print lacement in degree mechanical\n", + "#print lacement in degree electrical\n", + "delta_dash_elec = delta_dash_mech*(Poles/2)\n", + "\n", + "I = I_FL\n", + "phi = math.acos(0.8)\n", + "V = complex(V_ph*math.cos(phi),V_ph*math.sin(phi))\n", + "E = V+ I*X_s\n", + "\n", + "delta = (math.pi/180)*math.atan(E.imag/E.real)-phi \t\t\t#E leads I by (math.pi/180)*phasemag(E) and V leads I by phi radians \n", + "P_SY = abs(E)*abs(V_ph)*math.cos(delta)*math.sin(delta_dash_elec)/abs(X_s) \t\t\t#Synchronising power per phase \n", + "P_SY_total = 3*P_SY \t\t\t#total Synchronising power\n", + "\n", + "ns = 120*f/(60*Poles) \t\t\t#in r.p.m\n", + "T_SY = P_SY_total/(2*math.pi*ns) \t\t\t#Synchronising torque \n", + "\n", + "# Results\n", + "print 'Synchronising power per phase is %.3f kW'%(P_SY/1000)\n", + "print 'Synchronising torque is %.0f N-m'%(T_SY)\n", + "print 'Answer mismatches due to improper approximation'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power per phase is 197.555 kW\n", + "Synchronising torque is 5660 N-m\n", + "Answer mismatches due to improper approximation\n" + ] + } + ], + "prompt_number": 60 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.31 Page no : 87" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 3.3*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 3.*10**6\n", + "I_FL = VA/(math.sqrt(3)*V_L)\n", + "IX_s = (20./100)*V_ph \t\t\t#product of I and X_s\n", + "X_s = complex(0,IX_s/I_FL)\n", + "N_s = 1000. \t\t\t#in r.p.m\n", + "Poles = 6.\n", + "f = 50.\n", + "\n", + "# Calculations\n", + "delta_dash_mech = (math.pi/180) \t\t\t#print lacement in degree mechanical\n", + "#print lacement in degree electrical \n", + "delta_dash_elec = delta_dash_mech*(Poles/2)\n", + "\n", + "#E = V as the alternator is on no-load and X_s = Z_s\n", + "P_SY = abs(V_ph)**2*(delta_dash_elec)/abs(X_s) \t\t\t#Synchronising power per phase\n", + "P_SY_total = 3*P_SY \t\t\t#total Synchronising power\n", + "\n", + "ns = 120*f/(60*Poles) \t\t\t#in r.p.s\n", + "T_SY = P_SY_total/(2*math.pi*ns) \t\t\t#Synchronising torque \n", + "\n", + "# Results\n", + "print 'Synchronising power per phase is %.3f kW'%(P_SY/1000)\n", + "print 'Total Synchronising power is %.3f kW'%(P_SY_total/1000)\n", + "print 'Synchronising torque is %.0f N-m'%(T_SY)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power per phase is 261.799 kW\n", + "Total Synchronising power is 785.398 kW\n", + "Synchronising torque is 7500 N-m\n" + ] + } + ], + "prompt_number": 61 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.32 Page no : 88" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 11.*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 700.*10**3\n", + "I_FL = VA/(math.sqrt(3)*V_L)\n", + "IX_s = (14./100)*V_ph \t\t\t#product of I and X_s\n", + "X_s = IX_s/I_FL\n", + "#X_s = complex(0,IX_s/I_FL)\n", + "IR_a = (1.5/100)*V_ph \t\t\t#product of I and R_a\n", + "R_a = IR_a/I_FL\n", + "\n", + "\n", + "# Calculations\n", + "I = I_FL\n", + "phi = math.acos(0.8)\n", + "V = complex(V_ph*math.cos(phi),V_ph*math.sin(phi))\n", + "E_ph = math.sqrt( (V_ph*math.cos(phi)+IR_a)**2 +(V_ph*math.sin(phi)+IX_s)**2 )\n", + "delta = math.asin((V_ph*math.sin(phi)+IX_s)/E_ph) -phi\n", + "\n", + "Poles = 4.\n", + "f = 50.\n", + "delta_dash_mech = (math.pi/180) \t\t\t#phase print lacemnt in degree mechanical\n", + "delta_dash_elec = delta_dash_mech*(Poles/2)\t\t\t#phase print lacemnt in degree electrical\n", + "\n", + "P_SY = abs(V_ph)*abs(E_ph)*math.cos(delta)*math.sin(delta_dash_elec)/abs(X_s) \t\t\t#Synchronising power per phase\n", + "P_SY_total = 3*P_SY \t\t\t#total Synchronising power\n", + "\n", + "ns = 120*f/(60*Poles) \t\t\t#in r.p.s\n", + "T_SY = P_SY_total/(2*math.pi*ns) \t\t\t#Synchronising torque \n", + "\n", + "# Results\n", + "print 'Synchronising power per phase is %.3f kW'%(P_SY/1000)\n", + "print 'Synchronising power is %.3f kW ; '%(P_SY/1000)\n", + "print 'Total Synchronising power is %.3f kW'%(P_SY_total/1000)\n", + "print 'Synchronising torque is %.2f N-m'%(T_SY)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power per phase is 63.750 kW\n", + "Synchronising power is 63.750 kW ; \n", + "Total Synchronising power is 191.249 kW\n", + "Synchronising torque is 1217.53 N-m\n" + ] + } + ], + "prompt_number": 62 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.33 Page no : 91" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import cmath\n", + "\n", + "#note that a new function p2z has been defined below for direct representation of complex numbers in polar form\n", + "def p2z(RRRR,Theeeta):\n", + " return RRRR*cmath.exp(1j*math.pi*Theeeta/180.);\n", + "\n", + "# Variables\n", + "Z1 = complex(0,2)\n", + "Z2 = complex(0,3)\n", + "Z = 6.\n", + "E1 = p2z(230,0)\n", + "E2 = p2z(230,10)\n", + "\n", + "# Calculations\n", + "I1 = ((E1-E2)*Z+E1*Z2)/(Z*(Z1+Z2)+Z1*Z2)\n", + "I2 = ((E2-E1)*Z+E2*Z1)/(Z*(Z1+Z2)+Z1*Z2)\n", + "\n", + "phi1 = math.atan(I1.imag/I1.real) \t\t\t#Phasemag returns the angle of complex number in degrees\n", + "phi2 = math.atan(I2.imag/I2.real) \t\t\t#Phasemag returns the angle of complex number in degrees\n", + "\n", + "I = I1+I2\n", + "V = I*Z \t\t\t#Terminal voltage\n", + "\n", + "# Results\n", + "print 'i) Terminal voltage is %.2f volts at %.1f degrees'%(abs(V),math.degrees(math.atan(V.imag/V.real)))\n", + "print 'ii) Currents are %.2f A at %.0f degrees and %.2f A at %.2f degrees \\\n", + "\\nTotal current is %.2f A at %.1f degrees '%(abs(I1),math.degrees(math.atan(I1.imag/I1.real)),abs(I2),\\\n", + " math.degrees(math.atan(I2.imag/I2.real)),abs(I) \\\n", + " ,math.degrees(math.atan(I.imag/I.real)))\n", + "\n", + "P1 = abs(V)*abs(I1)*math.cos(math.radians(phi1))\n", + "P2 = abs(V)*abs(I2)*math.cos(math.radians(phi2))\n", + "print 'iii)Power delivered %.2f watts and %.2f watts'%(P1,P2)\n", + "\n", + "# note : rounding off error. kindly check the calculations\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i) Terminal voltage is 224.71 volts at -7.3 degrees\n", + "ii) Currents are 14.74 A at -14 degrees and 22.88 A at -3.03 degrees \n", + "Total current is 37.45 A at -7.3 degrees \n", + "iii)Power delivered 3311.43 watts and 5141.03 watts\n" + ] + } + ], + "prompt_number": 65 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.34 Page no : 91" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "X_d = 0.8\n", + "X_q = 0.5 \t\t\t#both per unit\n", + "R_a = 0. \t\t\t#assumed\n", + "phi = math.acos(0.8)\n", + "V_t = 1.\t\t\t#pu\n", + "I_a = 1. \t\t\t#full-load\n", + "\n", + "# Calculations\n", + "psi = math.atan( (V_t*math.sin(phi)+I_a*X_q)/(V_t*math.cos(phi)+I_a*R_a) )\n", + "delta = psi-phi\n", + "I_d = I_a*math.sin(psi)\n", + "I_q = I_a*math.cos(psi)\n", + "E_f = V_t*math.cos(delta)+I_d*X_d+I_q*R_a\n", + "\n", + "# Results\n", + "print 'Open circuit voltage is %.3f p.u.'%(E_f)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Open circuit voltage is 1.603 p.u.\n" + ] + } + ], + "prompt_number": 66 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.35 Page no : 92" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import *\n", + "\n", + "# Variables\n", + "V_L = 6600.\n", + "I_L = 110.\n", + "phi_1 = math.acos(0.9) \t\t\t#lagging\n", + "kW = array([400,1000,400,300])*10**3\n", + "cosphi = array([1,0.71,0.8,0.9])\n", + "tanphi = tan(arccos(cosphi))\n", + "kVAR = kW*tanphi\n", + "\n", + "# Calculations\n", + "kW_total = kW[0]+kW[1]+kW[2]+kW[3]\n", + "kVAR_total = kVAR[0]+kVAR[1]+kVAR[2]+kVAR[3]\n", + "\n", + "phi_c = math.atan(kVAR_total/kW_total) \t\t\t#total power factor angle\n", + "load_1 = math.sqrt(3)*V_L*I_L*math.cos(phi_1)\n", + "\n", + "kW_1 = load_1 \t\t\t#active component of machine 1\n", + "kVAR_1 = kW_1*math.tan(phi_1) \t\t\t#reactive component of machine 1\n", + "kW_2 = kW_total - kW_1 \t\t\t#active component of machine 1\n", + "kVAR_2 = kVAR_total-kVAR_1 \t\t\t#reactive component of machine 2\n", + "\n", + "phi_2 = math.atan(kVAR_2/kW_2) \n", + "pf_2 = math.cos(phi_2) \t\t\t#power factor of machine 2\n", + "\n", + "# Results\n", + "print 'Output of second alternator = %.2f kW'%(kW_2/1000)\n", + "print 'Power factor of machine 2 = %.4f and lagging'%(pf_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Output of second alternator = 968.28 kW\n", + "Power factor of machine 2 = 0.7366 and lagging\n" + ] + } + ], + "prompt_number": 67 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.36 Page no : 93" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 11000.\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 2.*10**6\n", + "phi = math.acos(0.8)\n", + "I_FL = VA/(math.sqrt(3)*V_L)\n", + "phi_1 = math.acos(0.8)\n", + "IX_s = (20./100)*V_ph \t\t\t#product of I and X_s\n", + "\n", + "# Calculations\n", + "X_s = IX_s/I_FL\n", + "I_1 = I_FL\n", + "BC = I_1*math.cos(phi_1)*X_s\n", + "AB = I_1*math.sin(phi_1)*X_s \n", + "OA = V_ph\n", + "OC = math.sqrt( (OA+AB)**2+(BC)**2 ) \n", + "E_1 = OC\n", + "E_2 = 1.25*E_1\n", + "OE = E_2\n", + "DE = BC\n", + "AD = math.sqrt(OE**2-DE**2) -OA \t\t\t#because OE = math.sqrt( (OA+AD)**2 + (DE)**2 )\n", + "\n", + "I_2sinphi2 = AD/X_s\n", + "I_2cosphi2 = I_1*math.cos(phi)\n", + "I_2 = math.sqrt( (I_2cosphi2)**2 + (I_2sinphi2)**2 )\n", + "phi2 = math.atan( I_2sinphi2/ I_2cosphi2 )\n", + "new_pf = math.cos(phi2)\n", + "\n", + "# Results\n", + "print 'Machine current is %.2f A '%(I_2)\n", + "print 'Power factor is %.4f lagging'%(new_pf)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Machine current is 228.62 A \n", + "Power factor is 0.3673 lagging\n" + ] + } + ], + "prompt_number": 68 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.37 Page no : 95" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#note that a new function p2z has been defined below for direct representation of complex numbers in polar form\n", + "def p2z(RRRR,Theeeta):\n", + " return RRRR*exp(1j*math.pi*Theeeta/180.);\n", + "\n", + "\n", + "# Variables\n", + "P_out = 3000.*10**3\n", + "V_L = 6.6*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "phi = math.acos(0.8)\n", + "I_L = p2z(P_out/(math.sqrt(3)*V_L*math.cos(phi)),-1*(180/math.pi)*phi)\n", + "\n", + "# Calculations\n", + "P_out1 = P_out/2\n", + "I_L1 = 150 \t\t\t#given\n", + "phi_L1 = math.acos( P_out1/(math.sqrt(3)*V_L*I_L1) )\n", + "I_L1 = p2z(I_L1,-1*(180/math.pi)*phi_L1)\n", + "\n", + "I_L2 = I_L-I_L1\n", + "pf_2 = math.cos(math.atan(I_L2.imag/I_L2.real))\n", + "Z_1 = complex(0.5,10)\n", + "I_1 = I_L1\n", + "E_1 = V_ph + I_1*Z_1\n", + "delta_1 = math.atan(E_1.imag/E_1.real) \t\t\t#load angle of alternator 1\n", + "E_1L = math.sqrt(3)*E_1\n", + "\n", + "Z_2 = complex(0.4,12)\n", + "I_2 = I_L2\n", + "E_2 = V_ph + I_2*Z_2\n", + "delta_2 = (math.pi/180)*math.atan(E_2.imag/E_2.real) \t\t\t#load angle of alternator 2\n", + "\n", + "# Results\n", + "print 'Part i) Currents are %.0f A at %.1f degrees and %.1f A at %.1f degrees\\nTotal current is %.0f at %.2f' %(abs(I_L1),\\\n", + " math.degrees(math.atan(I_L1.imag/I_L1.real)),abs(I_L2),\\\n", + " math.degrees(math.atan(I_L2.imag/I_L2.real)),abs(I_L),math.degrees(math.atan(I_L.imag/I_L.real)))\n", + "print 'Part ii)Power factor is %.4f and lagging'%(math.cos(phi_L1))\n", + "print 'Part iii)emf are %.2f V at %.2f degrees and %.4f V at %.0f degrees'%(abs(E_1),\\\n", + " math.degrees(math.atan(E_1.imag/E_1.real)),abs(E_2),math.degrees(math.atan(E_2.imag/E_2.real)))\n", + "print 'Part iv)Power angles are %.2f degrees and %.0f degrees '%(180/math.pi*delta_1,(180/math.pi)*delta_2)\n", + "\n", + "# note : rounding off error. kindly check the calculations\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Part i) Currents are 150 A at -29.0 degrees and 180.6 A at -43.4 degrees\n", + "Total current is 328 at -36.87\n", + "Part ii)Power factor is 0.8748 and lagging\n", + "Part iii)emf are 4776.46 V at 15.49 degrees and 5565.7081 V at 16 degrees\n", + "Part iv)Power angles are 15.49 degrees and 0 degrees \n" + ] + } + ], + "prompt_number": 73 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.38 Page no : 97" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "Z1 = complex(0.2,2)\n", + "Z2 = Z1\n", + "ZL = complex(3,4)\n", + "Z = ZL\n", + "E1 = complex(2000,0)\n", + "E2 = complex(2200,100)\n", + "\n", + "# Calculations\n", + "I1 = ((E1-E2)*Z+E1*Z2)/(Z*(Z1+Z2)+Z1*Z2)\n", + "I2 = ((E2-E1)*Z+E2*Z1)/(Z*(Z1+Z2)+Z1*Z2)\n", + "\n", + "IL = I1+I2\n", + "V = IL*Z \t\t\t#Terminal voltage\n", + "\n", + "phi1 = math.atan(V.imag/V.real)-math.atan(I1.imag/I1.real) \t\t\t#Phasemag returns the angle of complex number in degrees\n", + "phi2 = math.atan(V.imag/V.real)-math.atan(I2.imag/I2.real) \t\t\t#Phasemag returns the angle of complex number in degrees\n", + "\n", + "Pout1 = math.sqrt(3)*math.sqrt(3)*abs(V)*abs(I1)*math.cos(math.radians(phi1))\n", + "Pout2 = math.sqrt(3)*math.sqrt(3)*abs(V)*abs(I2)*math.cos(math.radians(phi2))\n", + "\n", + "# Results\n", + "print 'Power delivered is %.2f kW and %.2f kW at power-factors %.4f lag and %.4f lag respectively'%(Pout1/1000,Pout2/1000,math.cos(math.radians(phi1)),math.cos(math.radians(phi2)))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Power delivered is 658.24 kW and 1253.92 kW at power-factors 0.9999 lag and 0.9999 lag respectively\n" + ] + } + ], + "prompt_number": 74 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.39 Page no : 99" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "f = 50.\n", + "P = 12.\n", + "V_L = 6600.\n", + "V_ph = V_L/math.sqrt(3)\n", + "VA = 2000.*10**3\n", + "I_FL = VA/(math.sqrt(3)*V_L)\n", + "\n", + "# Calculations\n", + "IX_s = (25./100)*V_ph \t\t\t#product of I and X_s\n", + "X_s = complex(0,IX_s/I_FL)\n", + "N_s = 12*f/P \t\t\t#in rpm\n", + "delta_dash_mech = (math.pi/180) \t\t\t#phase print lacemnt in degree mechanical\n", + "delta_dash_elec = delta_dash_mech*(P/2) \t\t\t#phase print lacemnt in degree electrical\n", + "\n", + "phi = math.acos(0.8) \t\t\t#lag\n", + "I = complex(I_FL*math.cos(-1*phi),I_FL*math.sin(-1*phi))\n", + "V = V_ph\n", + "E = V + I*X_s\n", + "delta = math.atan(E.imag/E.real)*(math.pi/180)\n", + "P_SY = abs(E)*abs(V)*math.cos(delta)*math.sin(delta_dash_elec)/abs(X_s)\n", + "P_SY_total = 3*P_SY\n", + "\n", + "# Results\n", + "print 'Synchronising power is %.2f kW'%(P_SY/1000)\n", + "print 'Total Synchronising power is %.2f kW'%(P_SY_total/1000)\n", + "\n", + "# note : rounding off error. kindly check." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronising power is 325.36 kW\n", + "Total Synchronising power is 976.09 kW\n" + ] + } + ], + "prompt_number": 76 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.40 Page no : 101" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 22000.\n", + "V_ph = V_L/math.sqrt(3)\n", + "power = 230.*10**6\n", + "phi = math.acos(1.)\n", + "I_FL = power/(math.sqrt(3)*V_L*math.cos(phi))\n", + "I_1 = I_FL\n", + "X_s = 1.2\n", + "\n", + "# Calculations\n", + "E_1 = math.sqrt( V_ph**2 + (I_1*X_s)**2 )\n", + "E_2 = 1.3*E_1\n", + "AC = math.sqrt( E_2**2-(I_1*X_s)**2 ) -V_ph \t\t\t# because E**2 = (V_ph+AC)**2+(I_1*X_s)**2\n", + "I2X_S = AC\n", + "\n", + "I_2cosphi2 = I_1 \t\t\t#because phi_2 = math.acos(I_1/I_2) \t\t\t#from ACD\n", + "I_2sinphi2 = AC/X_s\n", + "I_2 = math.sqrt( (I_2cosphi2)**2 + (I_2sinphi2)**2 )\n", + "phi2 = math.atan( I_2sinphi2/ I_2cosphi2 )\n", + "new_pf = math.cos(phi2)\n", + "\n", + "# Results\n", + "print 'Machine current is %.2f A '%(I_2)\n", + "print 'Power factor is %.4f and lagging'%(new_pf)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Machine current is 7274.58 A \n", + "Power factor is 0.8297 and lagging\n" + ] + } + ], + "prompt_number": 77 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.41 Page no : 102" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import cmath\n", + "\n", + "#note that a new function p2z has been defined below for direct representation of complex numbers in polar form\n", + "def p2z(RRRR,Theeeta):\n", + "\treturn RRRR*cmath.exp(1j*math.pi*Theeeta/180.);\n", + "\n", + "# Variables\n", + "P_out = 1500.*10**3\n", + "V_L = 3.3*10**3\n", + "phi = math.acos(0.8)\n", + "I_L = p2z(P_out/(math.sqrt(3)*V_L*math.cos(phi)),-1*math.acos(math.radians(0.8)))\n", + "\n", + "I_L1_magnitude = 150. \t\t\t#given\n", + "P_out1 = (3.*10**6)/2 \t\t\t#because load is EQUALLY shared between 2 alternators\n", + "pf_L1 = P_out1/(math.sqrt(3)*2*V_L*I_L1_magnitude) \t\t\t#operating pf of alternator 1\n", + "phi1 = math.acos(math.radians(pf_L1))\n", + "I_L1 = p2z(I_L1_magnitude,-1*phi1)\n", + "I_L2 = I_L-I_L1 \t\t\t#because I_L = I_L1 + I_L2\n", + "pf_L2 = math.cos(math.atan(I_L2.imag/I_L2.real))\n", + "\n", + "# Calculations\n", + "V_ph = 6.6*10**3/math.sqrt(3)\n", + "Z_1 = complex(0.5,10)\n", + "I_1 = I_L1\n", + "E_1 = V_ph + I_1*Z_1\n", + "delta_1 = math.atan(E_1.imag/E_1.real) \t\t\t#load angle of alternator 1\n", + "I_2 = I_L2\n", + "\n", + "Z_2 = complex(0.4,12)\n", + "E_2 = V_ph + I_2*Z_2\n", + "delta_2 = math.atan(E_2.imag/E_2.real) \t\t\t#load angle of alternator 1\n", + "\n", + "# Results\n", + "print 'for machine 1current is %.0f A at %.2f degrees \\nPower factor of %.4f laginduced emf \\\n", + " of %.2f V \\nload angle of %.2f degrees'%(abs(I_L1),math.degrees(math.atan(I_L1.imag/I_L1.real)),pf_L1,abs(E_1),delta_1)\n", + "print 'for machine 2current is %.1f A at %.1f degrees\\nPower factor of %.4f laginduced emf \\\n", + " of %.2f V\\nload angle of %.0f degrees'%(abs(I_L2),math.degrees(math.atan(I_L2.imag/I_L2.real)),pf_L2,abs(E_2),math.degrees(delta_2))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "for machine 1current is 150 A at -1.56 degrees \n", + "Power factor of 0.8748 laginduced emf of 4202.06 V \n", + "load angle of 0.36 degrees\n", + "for machine 2current is 178.0 A at -1.6 degrees\n", + "Power factor of 0.9996 laginduced emf of 4480.49 V\n", + "load angle of 28 degrees\n" + ] + } + ], + "prompt_number": 81 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.42 Page no : 104" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_l = 230\n", + "VA = 5*10**3\n", + "X_d = 12\n", + "X_q = 7\n", + "R_a = 0 \t\t\t#armature resistance and synchronous reactance of direct quadrature axis\n", + "phi = math.acos(1)\n", + "\n", + "# Calculations\n", + "I_l = VA/(V_l*math.sqrt(3))\n", + "V_ph = V_l/math.sqrt(3)\n", + "V_t = V_ph\n", + "I_a = I_l\n", + "\n", + "psi = math.atan( (V_t*math.sin(phi)+I_a*X_q)/(V_t*math.cos(phi)+I_a*R_a) )\n", + "delta = psi-phi\n", + "I_d = I_a*math.sin(psi)\n", + "I_q = I_a*math.cos(psi)\n", + "E_f = V_t*math.cos(delta)+I_d*X_d+I_q*R_a\n", + "\n", + "# Results\n", + "print 'Excitation voltage is %.3f V '%(E_f)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Excitation voltage is 193.852 V \n" + ] + } + ], + "prompt_number": 82 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.43 Page no : 104" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_l = 6.6*10**3\n", + "V_t = V_l/math.sqrt(3)\n", + "X_d = 23.2\n", + "X_q = 14.5\n", + "R_a = 0. \t\t\t#armature resistance and synchronous reactance of direct quadrature axis\n", + "VA = 1800.*10**3\n", + "phi = math.acos(0.8) \t\t\t#lag\n", + "\n", + "# Calculations and Results\n", + "I_a = VA/(V_l*math.sqrt(3))\n", + "\n", + "psi = math.atan( (V_t*math.sin(phi)-I_a*X_q)/(V_t*math.cos(phi)-I_a*R_a) ) \t\t\t#minus sign in numerator and denomenator for motors\n", + "delta = psi+phi\n", + "I_d = I_a*math.sin(psi)\n", + "I_q = I_a*math.cos(psi)\n", + "E_f = V_t*math.cos(delta)-I_d*X_d-I_q*R_a\n", + "print 'Excitation emf = %.4f V'%(E_f)\n", + "#P_m = ( V_t*E_f*math.sin(delta)/X_d ) + ((1/X_q)-(1/X_d))*0.5*math.sin(2*delta)*V_t**2\n", + "#P_m = 0.4996*math.cos(delta)+0.1877*math.sin(2*delta)\n", + "#for maximum power output differenciate and equate to zero\n", + "\n", + "delta_max = 63.4 \t\t\t#degree\n", + "\n", + "P_m_max = ((1/X_q)-(1/X_d))*0.5*math.sin(math.radians(2*delta_max))*V_t**2 \t\t\t#Maximuum load supplied with E_f = 0\n", + "print 'Maximum load the motor can supply is %.4f MW per phase '%(P_m_max*10**-6 )\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Excitation emf = 3042.2721 V\n", + "Maximum load the motor can supply is 0.1503 MW per phase \n" + ] + } + ], + "prompt_number": 83 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/DC_Machines_and_Synchronous_Machines/ch7.ipynb b/DC_Machines_and_Synchronous_Machines/ch7.ipynb new file mode 100755 index 00000000..a22a6459 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/ch7.ipynb @@ -0,0 +1,1711 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:95ca4467d5385b9a67e6a4c31c682e32bf0713e6d2ff74a5a89a56c51df83062" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 7 : Synchronous Motors" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.1 Page no : 27" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import numpy as np\n", + "\n", + "# Variables\n", + "V_l = 400.\n", + "R_a = 0.2\n", + "X_s = 2. \t\t\t#armature resistance and synchronous reactance\n", + "I_L = 25.\n", + "I_aph = I_L\n", + "V_ph = V_l/math.sqrt(3)\n", + "Z_s = complex(R_a,X_s) \t\t\t#synchronous impedance\n", + "angle = math.atan(Z_s.imag/Z_s.real)\n", + "angle = math.degrees(angle)\n", + "E_Rph=I_aph*abs(Z_s)\n", + "theta = (math.pi/180.)*angle \n", + "\n", + "# Calculations and Results\n", + "#case 1\n", + "phi = math.acos(0.8) \t\t\t#lagging\n", + "E_bph = math.sqrt( (E_Rph)**2 + (V_ph)**2 -2*E_Rph*V_ph*math.cos(theta-phi) )\n", + "print 'i)Back EMF induced with 0.8 lagging pf is %.3f V'%(E_bph)\n", + "\n", + "#case 2\n", + "phi = math.acos(0.9) \t\t\t#leading\n", + "E_bph = math.sqrt( (E_Rph)**2 + (V_ph)**2 -2*E_Rph*V_ph*math.cos(theta+phi) )\n", + "print 'ii)Back EMF induced with 0.8 lagging pf is %.3f V'%(E_bph)\n", + "\n", + "#case 3\n", + "phi = math.acos(1)\n", + "E_bph = math.sqrt( (E_Rph)**2 + (V_ph)**2 -2*E_Rph*V_ph*math.cos(theta) )\n", + "print 'iii)Back EMF induced with 0.8 lagging pf is %.3f V'%(E_bph)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Back EMF induced with 0.8 lagging pf is 200.386 V\n", + "ii)Back EMF induced with 0.8 lagging pf is 252.678 V\n", + "iii)Back EMF induced with 0.8 lagging pf is 231.406 V\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.2 Page no : 28" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import *\n", + "\n", + "# Variables\n", + "V_l = 500.\n", + "R_a = 0.4\n", + "X_s = 4. \t\t\t#armature resistance and synchronous reactance\n", + "Z_s = complex(R_a,X_s)\t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "theta = (math.pi/180)*angle\t\t\t#phasemag returns angle in degrees,not radians\n", + "V_ph = V_l/math.sqrt(3)\n", + "I_l = 50.\n", + "I_aph = I_l\n", + "E_Rph = I_aph*abs(Z_s)\n", + "\n", + "# Calculations and Results\t\t\n", + "#case 1\n", + "E_bline = 600\n", + "E_bph = E_bline/math.sqrt(3)\n", + "phi = math.acos( (-E_bph**2 + E_Rph**2 + V_ph**2 )/(2*E_Rph*V_ph) ) -theta \t\t\t#leading\n", + "#because E_bph = math.sqrt( (E_Rph)**2 + (V_ph)**2 -2*E_Rph*V_ph*math.cos(theta+phi) )\n", + "print 'i)power factor is %.4f leading'%(cos(phi))\n", + "\n", + "#case 2\n", + "E_bline = 380\n", + "E_bph = E_bline/math.sqrt(3)\n", + "phi = theta-math.acos( (-E_bph**2 + E_Rph**2 + V_ph**2 )/(2*E_Rph*V_ph) ) \t\t\t#leading\n", + "#because E_bph = math.sqrt( (E_Rph)**2 + (V_ph)**2 -2*E_Rph*V_ph*math.cos(theta-phi)\n", + "print 'ii)power factor is %.4f lagging'%(cos(phi))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)power factor is 0.9977 leading\n", + "ii)power factor is 0.8197 lagging\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.3 Page no : 29" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 6600.\n", + "P_out = 500.*10**3\n", + "eta = 83./100 \t\t\t#efficiency\n", + "R_a = 0.3\n", + "X_s = 3.2 \t\t\t#armature resistance and synchronous reactance\n", + "Z_s = complex(R_a,X_s) \t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "theta = (math.pi/180)* angle \t\t\t#phasemag returns the angle in degrees not radians\n", + "phi = math.acos(0.8) \t\t\t#leading\n", + "V_ph = V_L/math.sqrt(3)\n", + "P_in = P_out/eta\n", + "\n", + "# Calculations and Results\n", + "I_L = P_in/ (math.sqrt(3) * V_L * math.cos(phi) )\n", + "\n", + "# because P_in = math.sqrt(3) * V_L * I_L * math.cos(phi)\n", + "I_aph = I_L\n", + "E_Rph = I_aph*abs(Z_s)\n", + "E_bph = math.sqrt( (E_Rph)**2 + (V_ph)**2 -2*E_Rph*V_ph*math.cos(theta+phi) )\n", + "print 'i) Generated EmF on full loaad is %.2f V'%(E_bph)\n", + "\n", + "delta = math.degrees(math.asin( (E_Rph/E_bph))*math.sin(theta+phi) )\n", + "#This is obtained after applying sune rule to triangle OAB from thre phasor diagram\n", + "print 'ii) load angle is %.2f degrees'%(delta)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i) Generated EmF on full loaad is 3925.33 V\n", + "ii) load angle is 2.64 degrees\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.4 Page no : 32" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import roots\n", + "\n", + "# Variables\n", + "V_L = 500.\n", + "V_ph = V_L/math.sqrt(3)\n", + "phi = math.acos(0.9) \t\t\t\t#lagging\n", + "output_power = 17.*10**3\n", + "R_a = 0.8 \t\t\t\t\t\t\t#armaature reactance\n", + "mechanical_losses = 1300. \t\t\t#mechanical losses is W\n", + "P_m = output_power+mechanical_losses \t\t\t#gross mechanical power developed\n", + "\n", + "# P_m = input_power - stator losses\n", + "# input_power = 3* V_ph * I_aph * math.cos(phi)\n", + "# Stator losses = 3*I_aph**2*R_a\n", + "# solving above equations we get 2.4 I_a**2 - 779/.4225*I_a + 18300 = 0\n", + "I_a_eqn = [2.4, -779.4225, 18300]\n", + "I_a_roots = roots(I_a_eqn)\n", + "I_a = I_a_roots[1] \t\t\t#neglecting higher value\n", + "I_aph = I_a\n", + "print 'Current drawn by the motor is %.3f A'%(I_a)\n", + "\n", + "input_power = 3* V_ph * I_aph * math.cos(phi)\n", + "eta = 100*output_power/input_power\n", + "print 'Full load efficiency is %.2f percent'%(eta)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Current drawn by the motor is 25.478 A\n", + "Full load efficiency is 85.61 percent\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.5 Page no : 44" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "#subscript 1 is for industrial load and 2 for synchronous motor\n", + "P_1 = 800. \t\t\t# Active power in KW\n", + "phi_1 = math.acos(0.6) \t\t\t#lagging\n", + "Q_1 = P_1*math.tan(phi_1) \t\t\t#reactive power by load 1\n", + "\n", + "# Calculations and Results\n", + "output_power = 200.\n", + "eta = 91./100 \t\t\t#efficiency of synchronous motor\n", + "input_power = output_power/eta\n", + "P_2 = input_power\t\t\t# active power drawn by synchronous motor\n", + "P_T = P_1 + P_2 \t\t\t#combined total load of industry and synchronous motor\n", + "phi_T = math.acos(0.92 )\t\t\t#lagging\n", + "Q_T = P_T* math.tan(phi_T) \t\t\t#from power triangle\n", + "Q_2 = Q_T - Q_1 \t\t\t#it turns out to be negative indicating its leading nature\n", + "S_2 = math.sqrt( P_2**2 + Q_2**2 )\n", + "print 'Desired kVA rating of Synchronous motor is %.3f kVA'%(S_2)\n", + "\n", + "phi_2 = math.atan (Q_2/P_2)\n", + "print 'Power factor of synchronous motor is %.4f LEADING'%(math.cos(phi_2))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Desired kVA rating of Synchronous motor is 669.353 kVA\n", + "Power factor of synchronous motor is 0.3283 LEADING\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.6 Page no : 47" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 400.\n", + "output_power = 37.3*1000 \t\t\t#Watts on full load\n", + "Z_s = complex(0.2,1.6) \t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "theta = (math.pi/180)*angle \t\t\t#phase mag returns the angle in degrees and not raidians\n", + "phi = math.acos(0.9) \t\t\t#leading\n", + "V_ph = V_L/math.sqrt(3)\n", + "eta = 88. \t\t\t#efficiency in percentage\n", + "\n", + "# Calculations\n", + "input_power = 100*output_power/eta\n", + "I_L = input_power/(math.sqrt(3)*V_L*math.cos(phi))\n", + "I_aph = I_L\n", + "E_Rph = I_aph*abs(Z_s)\n", + "\n", + "E_bph = math.sqrt( (E_Rph)**2 + (V_ph)**2 -2*E_Rph*V_ph*math.cos(theta+phi) )\n", + "E_line = math.sqrt(3)*E_bph\n", + "\n", + "# Results\n", + "print 'Induced EMF is %.2f V and its line value is %.2f V'%(E_bph,E_line)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced EMF is 285.65 V and its line value is 494.75 V\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.7 Page no : 48" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 400.\n", + "input_power = 20.*1000 \n", + "R_a = 0.\n", + "X_s = 4. \t\t\t#armature reactance and synchronous reactance\n", + "Z_s = complex(R_a,X_s) \t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag))\n", + "\n", + "theta = (math.pi/180)*angle \t\t\t#phase mag returns the angle in degrees and not raidians\n", + "V_ph = V_L/math.sqrt(3)\n", + "E_bline = 550. \t\t\t#star connection\n", + "E_bph = E_bline/math.sqrt(3)\n", + "\n", + "# Calculations\n", + "I_a_cos_phi = input_power/(math.sqrt(3)*V_L) \t\t\t#product of I_a and math.cos(phi)\n", + "I_a_sin_phi = ( math.sqrt(E_bph**2- (abs(Z_s)*I_a_cos_phi)**2 ) -V_ph )/abs(Z_s)\t\t\t#from triangle DAB\n", + "phi = math.atan(I_a_sin_phi/I_a_cos_phi)\n", + "I_a = I_a_cos_phi/math.cos(phi) \n", + "\n", + "# Results\n", + "print 'Motor power fctor is %.3f Leading'%(cos(phi))\n", + "print 'Current drawn by the motor is %.2f A'%(I_a)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Motor power fctor is 0.872 Leading\n", + "Current drawn by the motor is 33.11 A\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.8 Page no : 50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 3300.\n", + "V_ph = V_L/math.sqrt(3)\n", + "R_a = 2.\n", + "X_s = 18. \t\t\t#armature reactance and synchronous reactance\n", + "Z_s = complex(R_a,X_s)\t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "\n", + "theta = (math.pi/180)*angle \t\t\t#phasemag returns angle in degrees not radians\n", + "E_bline = 3800.\n", + "E_bph = E_bline/math.sqrt(3)\n", + "\n", + "#part(i)\n", + "P_m_max = (E_bph*V_ph/abs(Z_s))- (E_bph**2/abs(Z_s))*math.cos(theta)\n", + "print 'i)Max total mechanical power developed that motor can develop is %.2f W per phase'%(P_m_max)\n", + "\n", + "#part(ii)\n", + "#from phasor diagram applying math.comath.sine rule to triangle OAB\n", + "E_Rph = math.sqrt( E_bph**2 + V_ph**2 -2*E_bph*V_ph*math.cos(theta) ) \n", + "I_aph = E_Rph/abs(Z_s)\n", + "print 'ii)Current at max power developed is %.1f A'%(I_aph)\n", + "\n", + "copper_loss = 3* I_aph**2 * R_a\n", + "P_in_max_total = 3 * P_m_max \t\t\t#input power at max power developed\n", + "total_P_in = P_in_max_total + copper_loss \t\t\t#total input power \n", + "pf = total_P_in/(math.sqrt(3)*I_aph*V_L)\n", + "print 'Power factor at max power developed is %.3f leading'%(pf)\n", + "\n", + "\n", + "# 'Answer in part1 mismatched because of improper approximation in book'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Max total mechanical power developed that motor can develop is 201452.30 W per phase\n", + "ii)Current at max power developed is 151.4 A\n", + "Power factor at max power developed is 0.857 leading\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.9 Page no : 51" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 500.\n", + "R_a = 0.03\n", + "X_s = 0.3 \t\t\t#armature reactance and synchronous reactance\n", + "Z_s = complex(R_a,X_s)\t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "\n", + "theta = (math.pi/180)*angle \t\t\t#phasemag returns angle in degrees not radians\n", + "phi = math.acos(0.8)\n", + "eta = 93/100.\n", + "output_power = 100.*746\n", + "input_power = output_power/eta\n", + "I_L = input_power/(math.sqrt(3)*V_L*math.cos(phi))\n", + "I_aph = I_L\n", + "E_Rph = I_aph*abs(Z_s)\n", + "\n", + "#from the phasor diagram\n", + "E_bph = math.sqrt( E_Rph**2 + (V_L/math.sqrt(3))**2 - 2*E_Rph*(V_L/math.sqrt(3))*math.cos(phi+theta) ) \n", + "\n", + "cu_losses = 3*(I_aph)**2*R_a \t\t\t#total copper losses\n", + "P_m = input_power - cu_losses \t\t\t#total mechanical power developed\n", + "\n", + "print 'EMF developed per phase is %.4f V \\nTotal mechanical power developed is %.1f watts'%(E_bph,P_m)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "EMF developed per phase is 308.1880 V \n", + "Total mechanical power developed is 79008.6 watts\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.10 Page no : 53" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 415.\n", + "V_ph = V_L \t\t\t#due to delta connection\n", + "E_bline = 520.\n", + "R_a = 0.5\n", + "X_s = 4. \t\t\t#armature reactance and synchronous reactance\n", + "Z_s = complex(R_a,X_s) \t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "\n", + "theta = (math.pi/180.)*angle \t\t\t#phasemag returns angle in degrees not radians\n", + "\n", + "delta = theta \t\t\t#for maximum power\n", + "P_m_max = (E_bline*V_ph/abs(Z_s))- (E_bline**2/abs(Z_s))*math.cos(theta)\n", + "P_m_max_total = 3* P_m_max\n", + "fi_loss = 1000. \t\t\t#frictional and iron losses\n", + "P_out_total = P_m_max_total-fi_loss \n", + "\n", + "HP_output = P_out_total/746 \t\t\t#converting watts to horse power\n", + "print 'HP output for maximum power output is %.2f HP'%(HP_output)\n", + "\n", + "#from the phasor diagram\n", + "E_Rph = math.sqrt( E_bline**2 + V_ph**2 -2*E_bline*V_ph*math.cos(delta) ) \n", + "I_aph = E_Rph/abs(Z_s)\n", + "I_L = I_aph*math.sqrt(3)\n", + "print 'Line current is %f A'%(I_L)\n", + "cu_loss_total = 3*(I_aph)**2*R_a \t\t\t#total copper losses\n", + "input_power = P_m_max_total+ cu_loss_total\n", + "pf = input_power/(math.sqrt(3)*I_L*V_L) \t\t\t#leading\n", + "print 'Power factor for maximum power output is %.2f leading '%(pf)\n", + "\n", + "eta = 100*P_out_total /input_power\n", + "print 'Efficiency for maximum power output is %.2f percent'%(eta)\n", + "\n", + "# 'Answer might mismatch because of improper approximation done in book'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "HP output for maximum power output is 180.48 HP\n", + "Line current is 268.015479 A\n", + "Power factor for maximum power output is 0.89 leading \n", + "Efficiency for maximum power output is 78.48 percent\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.11 Page no : 54" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "P = 8.\n", + "f = 50. \t\t\t#Pole and frequency\n", + "N_s = 120.*f/P \t\t\t#synchronous speed\n", + "V_L = 6.6*10**3 \n", + "V_ph = V_L/math.sqrt(3)\n", + "Z_s = complex(0.66,6.6) \t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "\n", + "theta = (math.pi/180)*angle \t\t\t#phasemag returns angle in degree not radians\n", + "E_bph = 4500.\n", + "input_power = 2500.*10**3\n", + "I_a_cosphi = input_power/(math.sqrt(3)*V_L) \t\t\t#Its product of I_a and math.cos(phi);I_a = I_l for star conneted load\n", + "\n", + "# Calculations\n", + "#applying math.comath.sine rule to triangle ABC from phasor diagram and solve \n", + "#math.tan(phi)**2 + 5.2252 math.tan(phi)-2.2432 = 0\n", + "p = [1, 5.2252, -2.2432]\n", + "tan_phi = roots(p)\n", + "phi = math.atan(tan_phi[1])\n", + "pf = math.cos(phi)\n", + "I_a = I_a_cosphi/ math.cos(phi)\n", + "\n", + "#apply math.sine rule to triangle ABC\n", + "delta = math.asin(I_a*abs(Z_s)*math.sin(theta+phi)/E_bph)\n", + "P_m = 3*E_bph*I_a*math.cos(delta+phi)\n", + "T_g = P_m/(2*math.pi*N_s/60)\n", + "\n", + "# Results\n", + "print 'i)Torque developed is %f N-m'%(T_g)\n", + "print 'ii)Input current is %.4f A'%(I_a)\n", + "print 'iii)Power factor is %.4f leading'%(pf)\n", + "print 'iv)Power angle is %.2f degrees '%((180/math.pi)*delta)\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Torque developed is 30437.047497 N-m\n", + "ii)Input current is 235.4472 A\n", + "iii)Power factor is 0.9288 leading\n", + "iv)Power angle is 19.48 degrees \n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.12 Page no : 57" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import roots\n", + "\n", + "# Variables\n", + "input_power = 15.*10**3\n", + "V_L = 400.\n", + "V_ph = V_L/math.sqrt(3)\n", + "E_b = 480.\n", + "E_bph = E_b/math.sqrt(3)\n", + "Z_s = complex(1,5) \t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "\n", + "theta = (math.pi/180)*angle \t\t\t#phasemag returns angle in degree not radians\n", + "\n", + "# Calculations\n", + "I_a_cosphi = input_power/(math.sqrt(3)*V_L) \t\t\t#product of I_a & math.cos(phi)\n", + "#Applying math.comath.sine rule to triangle OAB and solving\n", + "#math.tan(phi)**2+ 4.101*math.tan(phi)-1.7499 = 0\n", + "p = [1,4.101,-1.7449]\n", + "tan_phi = roots(p)\n", + "phi = math.atan(tan_phi[1]) \t\t\t#ignoring negative vaule\n", + "I_a = I_a_cosphi/ math.cos(phi)\n", + "\n", + "#applying math.sine rule to Triangle OAB\n", + "delta = math.asin( I_a*abs(Z_s)* math.sin(theta+phi)/E_bph )\n", + "\n", + "# Results\n", + "print 'Load angle is %.1f degrees'%(delta*180/math.pi)\n", + "print 'Armature current is %.4f A'%(I_a)\n", + "print 'Power factor is %.3f leading'%(cos(phi))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Load angle is 24.9 degrees\n", + "Armature current is 23.2283 A\n", + "Power factor is 0.932 leading\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.13 Page no : 59" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from numpy import roots\n", + "\n", + "# Variables\n", + "V_L = 400.\n", + "V_ph = V_L/math.sqrt(3)\n", + "E_b = 460.\n", + "E_bph = E_b/math.sqrt(3)\n", + "input_power = 3.75*10**3\n", + "Z_s = complex(1,8) \t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "\n", + "theta = math.degrees(angle) \t\t\t#phasemag returns angle in degree ,not radians\n", + "I_L_cos_phi = input_power/(math.sqrt(3)*V_L)\n", + "\n", + "# Calculations and Results\n", + "#Applying math.comath.sine rule to triangle OAB and solving further\n", + "#math.tan(phi)**2 + 458.366*math.tan(phi) -450.65 = 0 \n", + "p = [1,458.366-450.65]\n", + "tan_phi = roots(p)\n", + "\n", + "phi = math.atan(tan_phi[0]) \t\t\t#ignoring negative value\n", + "print 'Required power factor is %.4f leading'%(cos(phi))\n", + "I_L = I_L_cos_phi /math.cos(phi)\n", + "print 'Required current is %.4f A'%(I_L)\n", + "\n", + "# roots() python gives some different answer. Kindly check." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required power factor is 0.1285 leading\n", + "Required current is 42.1134 A\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.14 Page no : 60" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "#subscript 1 indicates induction motor 1\n", + "P_1 = 350.\n", + "phi_1 = math.acos(0.7071) \t\t\t#lagging\n", + "Q_1 = P_1*math.tan(phi_1)\t\t\t#from power triangle\n", + "\n", + "#subscript 2 indicates induction motor 2\n", + "P_2 = 190.\n", + "\n", + "# Calculations\n", + "#subscript T indicates total\n", + "P_T = P_1+P_2\n", + "phi_T = math.acos(0.9) \t\t\t#lagging\n", + "Q_T = P_T*math.tan(phi_T)\n", + "\n", + "Q_2 = Q_T-Q_1\n", + "kva_rating = math.sqrt(P_2**2+ Q_2**2)\n", + "\n", + "# Results\n", + "print 'kVA rating of synchronous motor is %.2f kVA'%(kva_rating)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "kVA rating of synchronous motor is 209.59 kVA\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.15 Page no : 61" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 400.\n", + "V_ph = V_L/math.sqrt(3)\n", + "Pole = 6.\n", + "f = 50.\n", + "R_a = 0.2\n", + "X_s = 3. \t\t\t#armature reactance and synchronous reactance\n", + "Z_s = complex(R_a,X_s)\t\t\t#synchronous impedance\n", + "theta = math.atan(Z_s.imag/Z_s.real) # calculates angle in radians\n", + "\n", + "N_s = 120*f/Pole \t\t\t#synchronous speed\n", + "\n", + "# Calculations\n", + "#subscript 1` refers to load 1\n", + "I_a1 = 20.\n", + "phi_1 = math.acos(1)\n", + "E_R1 = I_a1* abs(Z_s)\n", + "E_bph = math.sqrt( E_R1**2 + V_ph**2 - 2*E_R1*V_ph*math.cos(phi_1+theta) )\n", + "\n", + "#subscript 2` refers to load 2\n", + "I_a2 = 60.\n", + "E_R2 = I_a2* abs(Z_s)\n", + "phi_2 = math.acos ((E_R2**2 + V_ph**2 -E_bph**2 )/(2*E_R2*V_ph)) -theta \t\t\t#new power factor\n", + "\n", + "input_power = math.sqrt(3)*V_L*I_a2*math.cos(phi_2)\n", + "cu_loss = 3*I_a2**2*R_a\n", + "P_m = input_power-cu_loss\n", + "T_g = P_m /(2*math.pi*N_s/60) \t\t\t#gross mechanical power developed\n", + "\n", + "# Results\n", + "print 'Gross torque developed is %.4f N-m and new power factor is %.4f lagging'%(T_g,cos(phi_2))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Gross torque developed is 357.1971 N-m and new power factor is 0.9518 lagging\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.16 Page no : 63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 3300.\n", + "V_ph = V_L/math.sqrt(3)\n", + "E_bph = V_ph\n", + "Z_s = complex(0.5,5) \t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "\n", + "theta = (math.pi/180)*angle \t\t\t#phasemag returns angle in degrees, not radians\n", + "P = 8.\n", + "f = 50. \t\t\t#pole and frequency\n", + "delta_mech = 3. \t\t\t#mechanical angle in degrees by which rotor is behind\n", + "delta_elec = (P/2)*delta_mech \t\t\t#delta mech converted to electrical degrees\n", + "E_Rph = math.sqrt( E_bph**2 + V_ph**2 -2*E_bph*V_ph*math.cos(math.radians(delta_elec) )) \n", + "I_aph = E_Rph/abs(Z_s)\n", + "\n", + "#from the phasor diagram \n", + "phi = theta- math.asin( math.sin(math.radians(delta_elec))*E_bph/E_Rph )\n", + "pf = math.cos(phi)\n", + "print 'power factor of the motor is %.5f lagging'%(pf)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "power factor of the motor is 0.99999 lagging\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.17 Page no : 64" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 400.\n", + "V_ph = V_L/math.sqrt(3)\n", + "E_bph = V_ph\n", + "P = 4.\n", + "f = 50.\t\t\t#Pole and frequency\n", + "delta_mech = 4*(math.pi/180) \t\t\t#mechanical angle in degrees by which rotor is behind\n", + "delta_elec = delta_mech *(P/2) \t\t\t#delta_mech convertd to electrical degrees\n", + "Z_s = complex(0,2) \t\t\t#synchronous impedance\n", + "\n", + "# Calculations\n", + "#referring to phasor diagram\n", + "BC = E_bph*math.sin(delta_elec)\n", + "AB = E_bph\n", + "OA = V_ph\n", + "\n", + "AC = math.sqrt(AB**2-BC**2)\n", + "OC = OA-AC\n", + "phi = math.atan(OC/BC)\n", + "OB = math.sqrt(OC**2 + BC**2)\n", + "I_a = OB/abs(Z_s)\n", + "\n", + "# Results\n", + "print 'Armature current drawn by the motor is %.4f A'%(I_a)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature current drawn by the motor is 16.1096 A\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.18 Page no : 65" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 400.\n", + "V_ph = V_L/math.sqrt(3)\n", + "input_power = 5472.\n", + "Z_s = complex(0,10) \t\t\t#synchronous impedance\n", + "I_L_cosphi = input_power/(math.sqrt(3)*V_L) \t\t\t#product of I_L & math.cos(phi)\n", + "BC = 10*I_L_cosphi\n", + "AB = V_ph\n", + "OA = V_ph\n", + "\n", + "# Calculations\n", + "#from Triangle ABC in phasor diagram\n", + "AC = math.sqrt(AB**2- BC**2)\n", + "OC = OA - AC\n", + "\n", + "\t\t\t#from Triangle OCB \n", + "OB = math.sqrt( OC**2+ BC**2 )\n", + "E_Rph = OB\n", + "I_L = E_Rph/abs(Z_s)\n", + "\n", + "phi = math.atan(OC/BC)\n", + "pf = math.cos(phi)\n", + "delta = math.atan(BC/AC) \t\t\t#load angle\n", + "\n", + "# Results\n", + "print 'Power factor is %.4f lagging'%(pf)\n", + "print 'Load angle is %.0f degrees'%(delta*180/math.pi)\n", + "print 'Armature current is %.3f A'%(I_L)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Power factor is 0.9848 lagging\n", + "Load angle is 20 degrees\n", + "Armature current is 8.020 A\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.19 Page no : 67" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 6600.\n", + "V_ph = V_L/math.sqrt(3)\n", + "Z_s = complex(2,20) \t\t\t#synchronous impedance\n", + "angle = math.degrees(math.atan(Z_s.imag/Z_s.real))\n", + "\n", + "theta = (math.pi/180) * angle \t\t\t#phasemag returns angle in degrees not radians\n", + "P_1 = 1000*10**3\n", + "P_2 = 1500*10**3\n", + "phi_1 = math.acos(0.8) \t\t\t#leading\n", + "\n", + "# Calculations\n", + "I_L1 = P_1/(math.sqrt(3)*V_L*math.cos(phi_1))\n", + "I_a1ph = I_L1\n", + "E_R1ph = I_a1ph*abs(Z_s)\n", + "E_bph = math.sqrt( V_ph**2 + E_R1ph** -2*V_ph*E_R1ph*math.cos(theta+phi_1) )\n", + "I_a2_cosphi_2 = P_2/(math.sqrt(3)*V_L)\n", + "\n", + "#Refer to the phasor diagram and solving for I_y\n", + "#404I_y**2 -152399.968 I_y -4543000 = 0\n", + "p = [404, -152399.968, -4543000]\n", + "ans = roots(p)\n", + "I_y = abs(ans[1]) \t\t\t#becuase root 1 is too high and root is -ve\n", + "\n", + "I_a2 = complex(I_a2_cosphi_2,I_y)\n", + "phi_2 = math.degrees(math.atan(I_a2.imag/I_a2.real))\n", + "\n", + "print 'Required power factor is %.3f leading'%(math.cos(math.radians(phi_2)))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required power factor is 0.978 leading\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.20 Page no : 69" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "V_L = 2300.\n", + "V_ph = V_L/math.sqrt(3)\n", + "I_L = 200.\n", + "I_a = I_L\n", + "Z_s = complex(0.2,2.2) \t\t\t#synchronous impedance\n", + "theta = math.atan(Z_s.imag/Z_s.real)\n", + "phi = math.acos(0.5)\n", + "\n", + "# Calculations\n", + "E_Rph = I_a*abs(Z_s)\n", + "E_bph = math.sqrt( E_Rph**2 + V_ph**2 - 2*E_Rph*V_ph*math.cos(phi+theta) ) \n", + "\n", + "# Results\n", + "print 'Generated EMF per phase is %.3f V'%(E_bph)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Generated EMF per phase is 1708.045 V\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.21 Page no : 69" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 3300.\n", + "V_ph = V_L/math.sqrt(3)\n", + "E_bline = 3800.\n", + "E_bph = E_bline/math.sqrt(3)\n", + "\n", + "R_a = 2.\n", + "X_s = 18. \t\t\t#armature resistance and synchronous reactance\n", + "Z_s = complex(R_a,X_s) \t\t\t#synchronous impedance\n", + "theta = math.atan(Z_s.imag/Z_s.real)\n", + "\n", + "#part(i)\n", + "P_m_max = (E_bph*V_ph/abs(Z_s))- (E_bph**2/abs(Z_s))*math.cos(theta) \t\t\t#maximum total mechanical power\n", + "print 'i)Maximum total mechanical power that the motor can develop is %.2f W per phase'%(P_m_max )\n", + "#part(ii)\n", + "delta = theta \t\t\t#for max P_m\n", + "E_Rph = math.sqrt( E_bph**2 + V_ph**2 -2*E_bph*V_ph*math.cos(delta) ) \n", + "I_aph = E_Rph/abs(Z_s)\n", + "print 'ii)Current at maximum power developed is %.1f A'%(I_aph)\n", + "cu_loss_total = 3*I_aph**2*R_a \t\t\t#total copper loss\n", + "P_m_max_total = 3*P_m_max \t\t\t#total maximum total mechanical power\n", + "P_in_total = P_m_max_total+ cu_loss_total \t\t\t#total input power\n", + "\n", + "pf = P_in_total/(math.sqrt(3)*V_L*I_aph)\n", + "print ' Power factor at maximum power developed is %.3f leading'%(pf)\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Maximum total mechanical power that the motor can develop is 201452.30 W per phase\n", + "ii)Current at maximum power developed is 151.4 A\n", + " Power factor at maximum power developed is 0.857 leading\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.22 Page no : 71" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#subscript 1 refers to load 1\n", + "I_1 = 18.\n", + "phi_1 = math.acos(0.8)\n", + "V_L = 440.\n", + "S_1 = math.sqrt(3)*I_1*V_L /1000 \t\t\t#kVA for load 1\n", + "P_1 = S_1*math.cos(phi_1)\n", + "Q_1 = S_1*math.sin(phi_1)\n", + "\n", + "# Calculations\n", + "P_out = 6.\n", + "eta_motor = 88./100\n", + "P_2 = P_out/eta_motor\n", + "\n", + "P_T = P_1+P_2\n", + "phi_T = math.acos(1) \t\t\t#total power factor angle\n", + "Q_T = P_T*math.tan(phi_T)\n", + "\n", + "Q_2 = Q_T - Q_1 \t\t\t#kVAR supplied by motor\n", + "#this will have a negative sign just indicating its leading nature \n", + "phi_2 = math.atan(abs(Q_2)/P_2)\n", + "pf = math.cos(phi_2) \t\t\t#leading\n", + "S_2 = P_2/math.cos(phi_2) \t\t\t#kVA input to the motor\n", + "\n", + "# Results\n", + "print 'kVA input to the motor is %.3f kVA '%(S_2)\n", + "print 'Power factor when driving a 6kW mechanical load is %.4f leading'%(pf)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "kVA input to the motor is 10.688 kVA \n", + "Power factor when driving a 6kW mechanical load is 0.6379 leading\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.23 Page no : 72" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "output_power = 8.*10**3\n", + "V_L = 400.\n", + "V_ph = V_L/math.sqrt(3)\n", + "R_a = 0.\n", + "X_s = 8.\t\t\t#armature resistance and syncronous reactance\n", + "Z_s = complex(R_a,X_s) \t\t\t#synchronous impedance\n", + "theta = math.atan(Z_s.imag) \t\t\t# returns angle in radians \n", + "eta = 88./100\n", + "input_power = output_power/eta\n", + "\n", + "# Calculations and Results\n", + "#minimum current occurs at max power factors\n", + "phi = math.acos(1)\n", + "I_a_min = input_power/(math.sqrt(3)*V_L*math.cos(phi)) \t\t\t#required minimum current \n", + "print 'Minimum current is %.3f A'%(I_a_min)\n", + "E_R = I_a_min * abs(Z_s)\n", + "E_bph = math.sqrt( E_R**2 + V_ph**2 - 2*E_R*V_ph*math.cos(phi+theta) ) \n", + "print 'Induced EMF at full-load is %.3f V'%(E_bph)\n", + "\n", + "# note : rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Minimum current is 13.122 A\n", + "Induced EMF at full-load is 241.534 V\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.24 Page no : 73" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "R_a = 0.8\n", + "X_s = 5.\n", + "Z_s = complex(R_a,X_s) \t\t\t#armature resistance and syncronous reactance\n", + "theta = math.atan(Z_s.imag/Z_s.real) \t\t\t# returns angle in radians \n", + "alpha = (math.pi/2) - theta\n", + "V_t = 3300/math.sqrt(3)\n", + "P_e_in = 800./(3) \t\t\t#per phase\n", + "phi = math.acos(0.8) \t\t\t#leading\n", + "Q_e_in = -P_e_in*math.tan(phi)\n", + "\n", + "# Calculations\n", + "# using the following equation\n", + "# P_e_in = V_t**2*R_a/(abs(Z_s))**2 + V_t*E_b*math.sin(delta-alpha)/abs(Z_S)\n", + "# Q_e_in = V_t**2*X_s/(abs(Z_s))**2 - V_t*E_b*math.cos(delta-alpha)/abs(Z_S)\n", + "E_b_sin_delta_minus_9 = 407.2\n", + "E_b_cos_delta_minus_9 = 2413.6\n", + "#solving further\n", + "delta = math.atan(E_b_sin_delta_minus_9/E_b_cos_delta_minus_9 ) + 9\n", + "E_b = E_b_sin_delta_minus_9/math.sin(math.radians(delta-9))\n", + "\n", + "P_e_in_new = 1200*10**3/3\n", + "# using the following equation again\n", + "# P_e_in = V_t**2*R_a/(abs(Z_s))**2 + V_t*E_b*math.sin(delta-alpha)/abs(Z_S)\n", + "# Q_e_in = V_t**2*X_s/(abs(Z_s))**2 - V_t*E_b*math.cos(delta-alpha)/abs(Z_S)\n", + "\n", + "alpha = delta - math.asin(math.radians(P_e_in_new - V_t**2*R_a/(abs(Z_s))**2 ) / (V_t*E_b/abs(Z_s)))\n", + "Q_e_in_new = V_t**2*X_s/(abs(Z_s))**2 - V_t*E_b*math.cos(math.radians(delta - alpha))/abs(Z_s)\n", + "\n", + "pf = math.cos ( math.atan(abs(Q_e_in_new/P_e_in_new)))\n", + "\n", + "# Results\n", + "print 'New power factor is %.2f leading '%(pf)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New power factor is 0.01 leading \n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.25 Page no : 74" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 6.6*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "P_in = 900.*10**3\n", + "R_a = 0.\n", + "X_s = 20. \t\t\t#armature resistance and synchronous reactance \n", + "Z_s = complex(R_a,X_s) \t\t\t#synchronous impedance\n", + "theta = math.atan(Z_s.imag) \t\t\t# returns angle in radians \n", + "E_b_L = 8.6*10**3\n", + "E_bph = E_b_L/math.sqrt(3) \n", + "\n", + "# Calculations\n", + "#refer to phasor diagram\n", + "OA = V_ph\n", + "AB = E_bph \t\t\t#OB = E_Rph\n", + "\n", + "I_a_cosphi = P_in/(math.sqrt(3)*V_L) \t\t\t#I_a*math.cos(phi)\n", + "BC = I_a_cosphi*abs(Z_s) \t\t\t#BC is a vector in phasor diagram\n", + "\n", + "OC = math.sqrt(AB**2 -BC**2 )- OA \t\t\t#from phasor diagram\n", + "I_a_sinphi = OC/abs(Z_s) \t\t\t#product of I_a and math.sin(phi)\n", + "phi = math.atan (I_a_sinphi/I_a_cosphi)\n", + "I_a = I_a_cosphi/math.cos(phi) \t\t\t#product of I_a and math.cos(phi)\n", + "\n", + "# Results\n", + "print 'Motor current is %.3f A'%(I_a)\n", + "print 'Power factor of motor is %f leading'%(cos(phi))\n", + "print 'Note:There is slight mismatch in answer due to the approximation made during I_a* sinphi calculation'\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Motor current is 90.643 A\n", + "Power factor of motor is 0.868564 leading\n", + "Note:There is slight mismatch in answer due to the approximation made during I_a* sinphi calculation\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.26 Page no : 75" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "\n", + "# Variables\n", + "#subscipt 1 refers to factory load\n", + "P_1 = 1800.\n", + "phi_1 = math.acos(0.6) \t\t\t#lagging\n", + "Q_1 = P_1*math.tan(phi_1)\n", + "\n", + "#Subscript 2 refers to synchronous condenser\n", + "P_2 = 0.\n", + "\n", + "# Calculations\n", + "#Subscript T refers to combination of condenser and factory load\n", + "P_T = P_1+P_2\n", + "phi_T = math.acos(0.95) \t\t\t#lagging\n", + "Q_T = P_T*math.tan(phi_T)\n", + "\n", + "kva_rating = math.sqrt(P_T**2+ Q_T**2)\n", + "\n", + "Q_2 = Q_T - Q_1\n", + "\n", + "# Results\n", + "print 'i)kVA rating of synchronous condender is %.3f kVA Minus sign indicates leading nature'%(Q_2)\n", + "print 'ii)kVA rating of total factory is %.4f kVA'%(kva_rating)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)kVA rating of synchronous condender is -1808.369 kVA Minus sign indicates leading nature\n", + "ii)kVA rating of total factory is 1894.7368 kVA\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.27 Page no : 77" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "I_1 = 35.\n", + "phi_1 = math.acos(0.8)\n", + "V_L = 440.\n", + "S_1 = math.sqrt(3)*I_1*V_L /1000 \t\t\t#in kVA\n", + "\n", + "\n", + "# Calculations\n", + "P_1 = S_1*math.cos(phi_1)\n", + "Q_1 = S_1*math.sin(phi_1)\n", + "\n", + "P_out = 12. \t\t\t#motor load\n", + "eta_motor = 85./100\n", + "P_2 = P_out/eta_motor\n", + "\n", + "P_T = P_1 + P_2\n", + "phi_T = math.acos(1)\n", + "Q_T = P_T * math.tan(phi_T)\n", + "\n", + "\n", + "Q_2 = Q_T - Q_1 \t\t\t#kVA supplied by motor\n", + "#negative sign of Q_2 indicates its leading nature\n", + "phi_2 = math.atan(abs(Q_2)/P_2)\n", + "S_2 = P_2/math.cos(phi_2)\n", + "\n", + "# Results\n", + "print 'Power factor when motor supplies 12kW load is %.4f leading'%(math.cos(phi_2))\n", + "print 'kVA input to the motor is %.3f kVA'%(S_2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Power factor when motor supplies 12kW load is 0.6615 leading\n", + "kVA input to the motor is 21.341 kVA\n" + ] + } + ], + "prompt_number": 36 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.28 Page no : 78" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 400\n", + "V_ph = V_L/math.sqrt(3)\n", + "Z_s = complex(0.5,4) \t\t\t#synchronous impedance\n", + "theta = math.atan(Z_s.imag/Z_s.real) \t\t\t# returns angle in radians \n", + "\n", + "I_aph = 60.\n", + "phi = math.acos(0.866) \t\t\t#leading\n", + "power_losses = 2*10**3\n", + "\n", + "# Calculations\n", + "E_bph = math.sqrt( (I_aph*abs(Z_s))**2 + (V_ph)**2 - 2*(I_aph*abs(Z_s))*(V_ph)*math.cos(phi+theta) ) \n", + "delta = theta \t\t\t#for P_m_max\n", + "P_m_max = (E_bph*V_ph/abs(Z_s))- (E_bph**2/abs(Z_s))*math.cos(delta)\n", + "P_m_max_total = 3 * P_m_max\n", + "P_out_max = P_m_max_total- power_losses\n", + "\n", + "# Results\n", + "print 'Maximum power output is %.4f kW'%(P_out_max*10**-3)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum power output is 51.3899 kW\n" + ] + } + ], + "prompt_number": 37 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.29 Page no : 79" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 6.6*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "I_L = 50.\n", + "I_aph = I_L\n", + "Z_s = complex(1.5,8) \t\t\t#synchronous impedance\n", + "theta = math.atan(Z_s.imag/Z_s.real) \t\t\t# returns angle in radians \n", + "E_Rph = I_aph*abs(Z_s)\n", + "\n", + "# Calculations and Results\n", + "#part(i)\n", + "phi = math.acos(0.8)\n", + "P_in = math.sqrt(3)*V_L*I_L*math.cos(phi) \t\t\t#for both lag and lead supplied power will be the same\n", + "print 'i)Power supplied to the motor is %.3f kW'%(P_in*10**-3)\n", + "#part(ii)\n", + "E_bph_lag = math.sqrt( E_Rph**2 + V_ph**2 - 2*E_Rph*V_ph*math.cos(theta-phi) ) \t\t\t#for lagging power factor\n", + "#Note that E_bph_lag > V_ph\n", + "print 'ii)Induced EMF for 0.8 power factor lag is %.3f V'%(E_bph_lag)\n", + "E_bph_lead = math.sqrt( E_Rph**2 + V_ph**2 - 2*E_Rph*V_ph*math.cos(theta+phi) ) \t\t\t#for leading power factor\n", + "#Note that E_bph_lead < V_ph\n", + "print ' Induced EMF for 0.8 power factor lead is %.3f V'%(E_bph_lead)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "i)Power supplied to the motor is 457.261 kW\n", + "ii)Induced EMF for 0.8 power factor lag is 3521.267 V\n", + " Induced EMF for 0.8 power factor lead is 4007.170 V\n" + ] + } + ], + "prompt_number": 38 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.30 Page no : 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 400.\n", + "V_ph = V_L/math.sqrt(3)\n", + "P_out = 7.5*735.5\n", + "eta = 85./100 \t\t\t#efficiency\n", + "R_a = 0.\n", + "X_s = 10. \t\t\t#armature resistance and synchronous reactance\n", + "Z_s = complex(R_a,X_s)\t\t\t#synchronous impedance\n", + "theta = math.atan(Z_s.imag) \t\t\t# returns angle in radians \n", + "\n", + "# Calculations and Results\n", + "P_in = P_out/eta\n", + "phi = math.acos(1) \t\t\t#for mimimum current power factor is maximum\n", + "I_L = P_in/(math.sqrt(3)*V_L*math.cos(phi)) \n", + "I_aph = I_L\n", + "print 'Minimum current is %.3f A at full load condition '%(I_L)\n", + "\n", + "E_Rph = I_aph*abs(Z_s)\n", + "E_bph = math.sqrt( E_Rph**2 + V_ph**2 - 2*E_Rph*V_ph*math.cos(phi+theta) ) \n", + "print 'and corresponding EMF is %.4f V'%(E_bph)\n", + "\n", + "# note : rounding off error.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Minimum current is 9.367 A at full load condition \n", + "and corresponding EMF is 240.4216 V\n" + ] + } + ], + "prompt_number": 40 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.31 Page no : 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Variables\n", + "V_L = 3.3*10**3\n", + "V_ph = V_L/math.sqrt(3)\n", + "V_t = V_ph\n", + "Pole = 24.\n", + "f = 50. \t\t\t#Pole and frequency\n", + "P = 1000.*10**3\n", + "R_a = 0\n", + "X_s = 3.24 \t\t\t#armature resistance and synchronous reactance\n", + "Z_s = complex(R_a,X_s) \t\t\t#synchronous impedance\n", + "theta = math.atan(Z_s.imag) \t\t\t# returns angle in radians \n", + "phi = math.acos(1)\n", + "I_aph = P/(math.sqrt(3)*V_L*math.cos(phi))\n", + "\n", + "# Calculations\n", + "E_Rph = I_aph*abs(Z_s)\n", + "E_bph = math.sqrt( E_Rph**2 + V_ph**2 - 2*E_Rph*V_ph*math.cos(phi+theta) ) \n", + "\n", + "P_m_max = 3*(E_bph*V_ph/abs(Z_s)) \t\t\t#maximum power that can be delivered\n", + "N_s = 120*f/Pole \t\t\t#synchronous speed\n", + "T_max = P_m_max /(2*math.pi*N_s/60) \t\t\t#maximum torque that can be developed\n", + "\n", + "# Results\n", + "print 'Maximum power and torque the motor can deliver is %.3f kW and %.2f *10**3 Nm respectively'%(P_m_max*10**-3,T_max/1000)\n", + "\n", + "# rounding off error." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum power and torque the motor can deliver is 3211.633 kW and 122.68 *10**3 Nm respectively\n" + ] + } + ], + "prompt_number": 42 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/DC_Machines_and_Synchronous_Machines/screenshots/ch1.png b/DC_Machines_and_Synchronous_Machines/screenshots/ch1.png Binary files differnew file mode 100755 index 00000000..a18f9a05 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/screenshots/ch1.png diff --git a/DC_Machines_and_Synchronous_Machines/screenshots/ch1_1.png b/DC_Machines_and_Synchronous_Machines/screenshots/ch1_1.png Binary files differnew file mode 100755 index 00000000..a18f9a05 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/screenshots/ch1_1.png diff --git a/DC_Machines_and_Synchronous_Machines/screenshots/ch1_2.png b/DC_Machines_and_Synchronous_Machines/screenshots/ch1_2.png Binary files differnew file mode 100755 index 00000000..a18f9a05 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/screenshots/ch1_2.png diff --git a/DC_Machines_and_Synchronous_Machines/screenshots/ch4.png b/DC_Machines_and_Synchronous_Machines/screenshots/ch4.png Binary files differnew file mode 100755 index 00000000..4e0892cf --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/screenshots/ch4.png diff --git a/DC_Machines_and_Synchronous_Machines/screenshots/ch4_1.png b/DC_Machines_and_Synchronous_Machines/screenshots/ch4_1.png Binary files differnew file mode 100755 index 00000000..4e0892cf --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/screenshots/ch4_1.png diff --git a/DC_Machines_and_Synchronous_Machines/screenshots/ch4_2.png b/DC_Machines_and_Synchronous_Machines/screenshots/ch4_2.png Binary files differnew file mode 100755 index 00000000..4e0892cf --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/screenshots/ch4_2.png diff --git a/DC_Machines_and_Synchronous_Machines/screenshots/ch7.png b/DC_Machines_and_Synchronous_Machines/screenshots/ch7.png Binary files differnew file mode 100755 index 00000000..6244be52 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/screenshots/ch7.png diff --git a/DC_Machines_and_Synchronous_Machines/screenshots/ch7_1.png b/DC_Machines_and_Synchronous_Machines/screenshots/ch7_1.png Binary files differnew file mode 100755 index 00000000..6244be52 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/screenshots/ch7_1.png diff --git a/DC_Machines_and_Synchronous_Machines/screenshots/ch7_2.png b/DC_Machines_and_Synchronous_Machines/screenshots/ch7_2.png Binary files differnew file mode 100755 index 00000000..6244be52 --- /dev/null +++ b/DC_Machines_and_Synchronous_Machines/screenshots/ch7_2.png |
