diff options
Diffstat (limited to 'Electric_Machinery_and_Transformers_by_Irving_Kosow')
19 files changed, 11768 insertions, 0 deletions
diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/APPENDIX.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/APPENDIX.ipynb new file mode 100755 index 00000000..38a77ec0 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/APPENDIX.ipynb @@ -0,0 +1,101 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "APPENDIX A-3: APPLICABLE SECTIONS OF THE NATIONAL ELECTRIC CODE(NEC)"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1, Page number 594"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "hp = 5.0 #Power rating of motor(hp)\n",
+ "V = 220.0 #Voltage rating of motor(V)\n",
+ "Va_a = 180.0 #Armature voltage(V)\n",
+ "Va_b = 240.0 #Armature voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "I1 = 27.0 #Current(A). From Appendix A-3 table for 180V\n",
+ "I_L1 = I1*(Va_a/V) #Full load current(A)\n",
+ "I2 = 20.0 #Current(A). From Appendix A-3 table for 240V\n",
+ "I_L2 = I2*(Va_b/V) #Full load current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full-load current for armature voltage of 180 V , I_L1 = %.f A' %I_L1)\n",
+ "print('Case(b): Full-load current for armature voltage of 240 V , I_L2 = %.f A' %I_L2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full-load current for armature voltage of 180 V , I_L1 = 22 A\n",
+ "Case(b): Full-load current for armature voltage of 240 V , I_L2 = 22 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2, Page number 594"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "hp = 10.0 #Power rating of motor(hp)\n",
+ "V = 600.0 #Voltage rating of motor(V)\n",
+ "Va = 550.0 #Armature voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "I = 16.0 #Current(A). From Appendix A-3 table for 550 V\n",
+ "I_L = I*(Va/V) #Full load current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Line current at rated load , I_L = %.1f A' %I_L)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Line current at rated load , I_L = 14.7 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_1.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_1.ipynb new file mode 100755 index 00000000..dad6f062 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_1.ipynb @@ -0,0 +1,645 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 1: ELECTROMECHANICAL FUNDAMENTALS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.1, Page number 5"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "t = 50.0*10**-3 #Time(second)\n",
+ "phi = 8.0*10**6 #Uniform magnetic field(maxwells)\n",
+ "\n",
+ "#Calculation\n",
+ "E_av = (phi/t)*10**-8 #Average voltage generated in the conductor(V) \n",
+ "\n",
+ "#Result\n",
+ "print('Average voltage generated in the conductor , E_av = %.1f V' %E_av)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Average voltage generated in the conductor , E_av = 1.6 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.2, Page number 6"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "l = 18.0 #Length of the conductor(inches)\n",
+ "B = 50000.0 #Uniform magnetic field(lines/sq.inches)\n",
+ "d = 720.0 #Distance travelled by conductor(inches)\n",
+ "t = 1.0 #Time taken for the conductor to move(second)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "v = d/t #Velocity with which the conductor moves(inches/second)\n",
+ "e = B*l*v*10**-8 #Instantaneous induced EMF(V)\n",
+ "#Case(b)\n",
+ "A = d*l #Area swept by the conductor while moving(sq.inches)\n",
+ "phi = B*A #Uniform magnetic field(lines) \n",
+ "E = (phi/t)*10**-8 #Average induced EMF(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Instantaneous induced EMF , e = %.2f V' %e)\n",
+ "print('Case(b): Average induced EMF , E = %.2f V' %E)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Instantaneous induced EMF , e = 6.48 V\n",
+ "Case(b): Average induced EMF , E = 6.48 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.3, Page number 8"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "l = 18.0 #Length of the conductor(inches)\n",
+ "B = 50000.0 #Uniform magnetic field(lines/sq.inches)\n",
+ "d = 720.0 #Distance travelled by conductor(inches)\n",
+ "t = 1.0 #Time taken for the conductor to move(second)\n",
+ "theta = 75.0 #Angle between the motion of the conductor and field(degree)\n",
+ "\n",
+ "#Calculation\n",
+ "v = d/t #Velocity with which the conductor moves(inches/second)\n",
+ "E = B*l*v*math.sin(theta*math.pi/180)*10**-8 #Instantaneous induced voltage(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Average induced voltage , E = %.2f V' %E)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Average induced voltage , E = 6.26 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.4, Page number 9"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "v = 1.5 #Velocity of moving conductor(m/s)\n",
+ "l = 0.4 #Length of the conductor(m)\n",
+ "B = 1 #Uniform field(tesla)\n",
+ "theta_a = 90.0 #Angle between the motion of the conductor and field(Degree)\n",
+ "theta_b = 35.0 #Angle between the motion of the conductor and field(Degree)\n",
+ "theta_c = 120.0 #Angle between the motion of the conductor and field(Degree)\n",
+ "\n",
+ "#Calculation\n",
+ "E_a = B*l*v*math.sin(theta_a*math.pi/180) #Voltage induced in the conductor(V)\n",
+ "E_b = B*l*v*math.sin(theta_b*math.pi/180) #Voltage induced in the conductor(V)\n",
+ "E_c = B*l*v*math.sin(theta_c*math.pi/180) #Voltage induced in the conductor(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Voltage induced in the conductor , E = %.1f V' %E_a)\n",
+ "print('Case(b): Voltage induced in the conductor , E = %.3f V' %E_b)\n",
+ "print('Case(c): Voltage induced in the conductor , E = %.2f V' %E_c)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Voltage induced in the conductor , E = 0.6 V\n",
+ "Case(b): Voltage induced in the conductor , E = 0.344 V\n",
+ "Case(c): Voltage induced in the conductor , E = 0.52 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.5, Page number 19"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "no_of_conductors = 40.0 #Number of conductors\n",
+ "A = 2.0 #Number of parallel paths\n",
+ "path = A\n",
+ "flux_per_pole = 6.48*10**8 #Flux per pole(lines) \n",
+ "N = 30.0 #Speed of the prime mover(rpm)\n",
+ "R_per_path = 0.01 #Resistance per path\n",
+ "I = 10.0 #Current carrying capacity of each conductor(A)\n",
+ "P = 2.0 #Number of poles\n",
+ "\n",
+ "#Calculation\n",
+ "phi_T = P*flux_per_pole #Total flux linked in one revolution(lines)\n",
+ "t = (1/N)*(60) #Time for one revolution(s/rev)\n",
+ "#Case(a)\n",
+ "e_av_per_conductor = (phi_T/t)*10**-8 #Average voltage generated(V/conductor)\n",
+ "E_per_path = (e_av_per_conductor)*(no_of_conductors/path) #Average voltage generated(V/path)\n",
+ "#Case(b)\n",
+ "E_g = E_per_path #Generated armature voltage(V)\n",
+ "#Case(c)\n",
+ "I_a = (I/path)*(2*path) #Armature current delivered to an external load(A)\n",
+ "#Case(d)\n",
+ "R_a = (R_per_path)/path*(no_of_conductors/P) #Armature resistance(ohm)\n",
+ "#Case(e)\n",
+ "V_t = E_g-(I_a*R_a) #Terminal voltage of the generator(V)\n",
+ "#Case(f)\n",
+ "P = V_t*I_a #Generator power rating(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Average voltage generated per path , E/path = %.1f V/path' %E_per_path)\n",
+ "print('Case(b): Generated armature voltage , E_g = %.1f V' %E_g)\n",
+ "print('Case(c): Armature current delivered to an external load , I_a = %.f A' %I_a)\n",
+ "print('Case(d): Armature resistance , R_a = %.1f \u03a9' %R_a)\n",
+ "print('Case(e): Terminal voltage of the generator , V_t = %.1f V' %V_t)\n",
+ "print('Case(f): Generator power rating , P = %.f W' %P)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Average voltage generated per path , E/path = 129.6 V/path\n",
+ "Case(b): Generated armature voltage , E_g = 129.6 V\n",
+ "Case(c): Armature current delivered to an external load , I_a = 20 A\n",
+ "Case(d): Armature resistance , R_a = 0.1 \u03a9\n",
+ "Case(e): Terminal voltage of the generator , V_t = 127.6 V\n",
+ "Case(f): Generator power rating , P = 2552 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.6, Page number 20"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "no_of_conductors = 40.0 #Number of conductors\n",
+ "path = 4.0 #Number of parallel paths\n",
+ "flux_per_pole = 6.48*10**8 #Flux per pole(lines) \n",
+ "N = 30.0 #Speed of the prime mover(rpm)\n",
+ "R_per_path = 0.01 #Resistance per path\n",
+ "I = 10.0 #Current carrying capacity of each conductor(A)\n",
+ "P = 4.0 #Number of poles\n",
+ "\n",
+ "#Calculation\n",
+ "phi_T = 2*flux_per_pole #Total flux linked in one revolution(lines). From Example 1.5\n",
+ "t = (1/N)*(60) #Time for one revolution(s/rev)\n",
+ "#Case(a)\n",
+ "e_av_per_conductor = (phi_T/t)*10**-8 #Average voltage generated(V/conductor)\n",
+ "E_per_path = (e_av_per_conductor)*(no_of_conductors/path) #Average voltage generated(V/path)\n",
+ "#Case(b)\n",
+ "E_g = E_per_path #Generated armature voltage(V)\n",
+ "#Case(c)\n",
+ "I_a = (I/path)*(4*path) #Armature current delivered to an external load(A)\n",
+ "#Case(d)\n",
+ "R_a = (R_per_path)/path*(no_of_conductors/P) #Armature resistance(ohm)\n",
+ "#Case(e)\n",
+ "V_t = E_g-(I_a*R_a) #Terminal voltage of the generator(V)\n",
+ "#Case(f)\n",
+ "P = V_t*I_a #Generator power rating(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Average voltage generated per path , E/path = %.1f V/path' %E_per_path)\n",
+ "print('Case(b): Generated armature voltage , E_g = %.1f V' %E_g)\n",
+ "print('Case(c): Armature current delivered to an external load , I_a = %.f A' %I_a)\n",
+ "print('Case(d): Armature resistance , R_a = %.3f \u03a9' %R_a)\n",
+ "print('Case(e): Terminal voltage of the generator , V_t = %.1f V' %V_t)\n",
+ "print('Case(f): Generator power rating , P = %.f W' %P)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Average voltage generated per path , E/path = 64.8 V/path\n",
+ "Case(b): Generated armature voltage , E_g = 64.8 V\n",
+ "Case(c): Armature current delivered to an external load , I_a = 40 A\n",
+ "Case(d): Armature resistance , R_a = 0.025 \u03a9\n",
+ "Case(e): Terminal voltage of the generator , V_t = 63.8 V\n",
+ "Case(f): Generator power rating , P = 2552 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.7, Page number 23"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "N = 1.0 #Number of turns\n",
+ "phi = 6.48*10**8 #Magnetic flux(lines)\n",
+ "rpm = 30.0 #Number of revolution\n",
+ "s = rpm/60 #Number of revolution of the coil per second(rev/s)\n",
+ "\n",
+ "#Calculation\n",
+ "E_av_per_coil = 4*phi*N*s*10**-8 #Average voltage per coil(V/coil)\n",
+ "E_av_per_coil_side = E_av_per_coil*(1.0/2) #Average voltage per conductor(V/conductor)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Average voltage per coil , E_av/coil = %.2f V/coil' %E_av_per_coil)\n",
+ "print('Case(b): Average voltage per conductor , E_av/coil side = %.2f V/conductor' %E_av_per_coil_side)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Average voltage per coil , E_av/coil = 12.96 V/coil\n",
+ "Case(b): Average voltage per conductor , E_av/coil side = 6.48 V/conductor\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.8, Page number 23"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "N = 1.0 #Number of turns\n",
+ "phi_lines = 6.48*10**8 #Magnetic flux(lines/pole)\n",
+ "rpm = 30.0 #Number of revolution per second\n",
+ "s = rpm/60 #Number of revolution of the coil per second(rev/s)\n",
+ "\n",
+ "#Calculation\n",
+ "phi = phi_lines*10**-8 #Magnetic flux(Wb)\n",
+ "omega = rpm*2*math.pi*(1.0/60) #Angular velocity(rad/s)\n",
+ "E_av_per_coil = 0.63662*omega*phi*N #Average voltage per coil(V/coil)\n",
+ "\n",
+ "#Result\n",
+ "print('Average voltage per coil , E_av/coil = %.2f V/coil' %E_av_per_coil)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Average voltage per coil , E_av/coil = 12.96 V/coil\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.9, Page number 24"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 2.0 #Number of poles\n",
+ "Z = 40.0 #Number of conductors\n",
+ "a = 2.0 #Parallel paths\n",
+ "phi = 6.48*10**8 #Magnetic flux(lines/pole)\n",
+ "S = 30.0 #Speed of the prime mover\n",
+ "\n",
+ "#Calculation\n",
+ "E_g = (phi*Z*S*P)/(60*a)*10**-8 #Average voltage between the brushes(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Average voltage between the brushes , E_g = %.1f V' %E_g)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Average voltage between the brushes , E_g = 129.6 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.10, Page number 24"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "no_of_coils = 40.0 #Number of coils\n",
+ "N = 20.0 #Number of turns in each coil\n",
+ "omega = 200.0 #Angular velocity of armature(rad/s)\n",
+ "phi = 5.0*10**-3 #Flux(Wb/pole)\n",
+ "a = 4.0 #Number of parallel paths\n",
+ "P = 4.0 #Number of poles\n",
+ "\n",
+ "#Calculation\n",
+ "Z = no_of_coils*2.0*N #Number of conductors\n",
+ "E_g = (phi*Z*omega*P)/(2*math.pi*a) #Voltage generated by the armature between brushes(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Number of conductors , Z = %.f conductors' %Z)\n",
+ "print('Case(b): Voltage between brushes generated by the armature , E_g = %.1f V' %E_g)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Number of conductors , Z = 1600 conductors\n",
+ "Case(b): Voltage between brushes generated by the armature , E_g = 254.6 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.11, Page number 26"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "l = 0.5 #Length of the conductor(m)\n",
+ "A = 0.1*0.2 #Area of the pole face(sq.meter)\n",
+ "phi = 0.5*10**-3 #Magnetic flux(Wb)\n",
+ "I = 10.0 #Current in the conductor(A)\n",
+ "\n",
+ "#Calculation\n",
+ "B = phi/A #Flux density(Wb/m^2)\n",
+ "F = B*I*l*1000 #Magnitude of force(mN)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Magnitude of the force , F = %.f mN' %F)\n",
+ "print('Case(b): The direction of the force on the conductor is %.f mN in an upward direction' %F)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Magnitude of the force , F = 125 mN\n",
+ "Case(b): The direction of the force on the conductor is 125 mN in an upward direction\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.12, Page number 26"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "l = 0.5 #Length of the conductor(m)\n",
+ "A = 0.1*0.2 #Area of the pole face(sq.meter)\n",
+ "phi = 0.5*10**-3 #Magnetic flux(Wb)\n",
+ "I = 10.0 #Current in the conductor(A)\n",
+ "theta = 75.0 #Angle between the conductor and the flux density(degree)\n",
+ "\n",
+ "#Calculation\n",
+ "B = phi/A #Flux density(Wb/m^2)\n",
+ "F = B*I*l*math.sin(theta*math.pi/180)*1000 #Magnitude of force(mN)\n",
+ "\n",
+ "#Result\n",
+ "print('Magnitude of the force , F = %.2f mN in an vertically upward direction' %F)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Magnitude of the force , F = 120.74 mN in an vertically upward direction\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.13, Page number 29"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "R_a = 0.25 #Armature resistance(ohm)\n",
+ "V_a = 125.0 #DC bus voltage(V)\n",
+ "I_a = 60.0 #Armature current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "E_c = V_a-(I_a*R_a) #Counter EMF generated in the armature conductors of motor(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Counter EMF generated in the armature conductors of motor , E_c = %.f V' %E_c)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Counter EMF generated in the armature conductors of motor , E_c = 110 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 1.14, Page number 29"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_a = 110.0 #Voltage across armature(V)\n",
+ "I_a = 60.0 #Armature current(A)\n",
+ "R_a = 0.25 #Armature resistance(ohm)\n",
+ "P = 6.0 #Number of poles\n",
+ "a = 12.0 #Number of paths\n",
+ "Z = 720.0 #No. of armature conductors\n",
+ "S = 1800.0 #Speed(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "E_g = V_a+(I_a*R_a) #Generated EMF in the armature(V)\n",
+ "phi_lines = E_g*60*a/(Z*S*P*10**-8) #Flux per pole in lines(lines/pole)\n",
+ "phi_mWb = phi_lines*10**-8*1000 #Flux per pole milliwebers(mWb)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Generated EMF in the armature , E_g = %.f V' %E_g)\n",
+ "print('Case(b): Flux per pole in lines , \u03a6 = %.2e lines/pole' %phi_lines)\n",
+ "print('Case(c): Flux per pole milliwebers , \u03a6 = %.1f mWb' %phi_mWb)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Generated EMF in the armature , E_g = 125 V\n",
+ "Case(b): Flux per pole in lines , \u03a6 = 1.16e+06 lines/pole\n",
+ "Case(c): Flux per pole milliwebers , \u03a6 = 11.6 mWb\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_10.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_10.ipynb new file mode 100755 index 00000000..0689055e --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_10.ipynb @@ -0,0 +1,253 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 10: SINGLE-PHASE MOTORS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 10.1, Page number 341"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "hp = 0.25 #Power rating of the single-phase motor(hp)\n",
+ "V = 110.0 #Voltage rating of the single-phase motor(V)\n",
+ "I_sw = 4.0 #Starting winding current(A)\n",
+ "phi_I_sw = 15.0 #Phase angle by which I_sw lags behind V(degree)\n",
+ "I_rw = 6.0 #Running winding current(A)\n",
+ "phi_I_rw = 40.0 #Phase angle by which I_rw lags behind V(degree) \n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "I_s = I_sw*cmath.exp(1j*-phi_I_sw*math.pi/180) #Starting current(A)\n",
+ "I_r = I_rw*cmath.exp(1j*-phi_I_rw*math.pi/180) #Running current(A)\n",
+ "I_t = I_s+I_r #Total starting current(A)\n",
+ "I_t_angle = cmath.phase(I_t)*180/math.pi #Angle of total starting current(degree)\n",
+ "Power_factor = math.cos(I_t_angle*math.pi/180) #Power factor\n",
+ "#Case(b)\n",
+ "Is_cos_theta = I_s.real #Component of starting winding current in phase with the supply voltage(A)\n",
+ "#Case(c)\n",
+ "Ir_sin_theta = I_r.imag #Component of running winding current that lags the supply voltage by 90\u00b0(A)\n",
+ "#Case(d)\n",
+ "phase = (phi_I_rw-phi_I_sw) #Phase angle between the starting and running currents(degree)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Total starting current , I_t = %.2f\u2220%.f\u00b0 A' %(abs(I_t),I_t_angle))\n",
+ "print(' Power factor = %.3f lagging' %Power_factor)\n",
+ "print('Case(b): Component of starting winding current in phase with the supply voltage , I_s*cos\u03b8 = %.2f A' %Is_cos_theta)\n",
+ "print('Case(c): Component of running winding current that lags the supply voltage by 90\u00b0 , I_r*sin\u03b8 = %.2fj A' %Ir_sin_theta)\n",
+ "print('Case(d): Phase angle between starting and running currents , (\u03b8_r-\u03b8_s) = %.f\u00b0 ' %phase)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Total starting current , I_t = 9.77\u2220-30\u00b0 A\n",
+ " Power factor = 0.866 lagging\n",
+ "Case(b): Component of starting winding current in phase with the supply voltage , I_s*cos\u03b8 = 3.86 A\n",
+ "Case(c): Component of running winding current that lags the supply voltage by 90\u00b0 , I_r*sin\u03b8 = -3.86j A\n",
+ "Case(d): Phase angle between starting and running currents , (\u03b8_r-\u03b8_s) = 25\u00b0 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 10.2, Page number 341"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "hp = 0.25 #Power rating of the single-phase motor(hp)\n",
+ "V = 110.0 #Voltage rating of the single-phase motor(V)\n",
+ "I_s = 4.0 #Starting winding current(A)\n",
+ "phi_I_s = 15.0 #Phase angle by which I_sw lags behind V(degree)\n",
+ "I_r = 6.0 #Running winding current(A)\n",
+ "phi_I_r = 40.0 #Phase angle by which I_rw lags behind V(degree) \n",
+ "\n",
+ "#Calculation\n",
+ "P_s = V*I_s*math.cos(phi_I_s*math.pi/180) #Power dissipated by starting winding(W)\n",
+ "P_r = V*I_r*math.cos(phi_I_r*math.pi/180) #Power dissipated in the running winding(W)\n",
+ "P_t = P_s+P_r #Total instantaneous power dissipated during starting(W)\n",
+ "P_r_d = P_r #Total steady-state power dissipated during running(W)\n",
+ "n = hp*746/P_r*100 #Efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Power dissipated by the starting winding , P_s = %.f W' %P_s)\n",
+ "print('Case(b): Power dissipated in the running winding , P_r = %.1f W' %P_r)\n",
+ "print('Case(c): Total instantaneous power dissipated during starting , P_t = %.1f W' %P_t)\n",
+ "print('Case(d): Total steady-state power dissipated during running , P_r = %.1f W' %P_r_d)\n",
+ "print('Case(e): Motor efficiency , \u03b7 = %.f percent' %n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Power dissipated by the starting winding , P_s = 425 W\n",
+ "Case(b): Power dissipated in the running winding , P_r = 505.6 W\n",
+ "Case(c): Total instantaneous power dissipated during starting , P_t = 930.6 W\n",
+ "Case(d): Total steady-state power dissipated during running , P_r = 505.6 W\n",
+ "Case(e): Motor efficiency , \u03b7 = 37 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 10.3, Page number 345"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "hp = 0.25 #Power rating of the single-phase motor(hp)\n",
+ "V = 110.0 #Voltage rating of the single-phase motor(V)\n",
+ "I_sw = 4.0 #Starting winding current(A)\n",
+ "phi_I_sw = 42.0 #Phase angle by which I_sw lead V(degree)\n",
+ "I_rw = 6.0 #Running winding current(A)\n",
+ "phi_I_rw = 40.0 #Phase angle by which I_rw lags behind V(degree) \n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "I_s = I_sw*cmath.exp(1j*phi_I_sw*math.pi/180) #Starting current(A)\n",
+ "I_r = I_rw*cmath.exp(1j*-phi_I_rw*math.pi/180) #Running current(A)\n",
+ "I_t = I_s+I_r #Total starting current(A)\n",
+ "I_t_angle = cmath.phase(I_t)*180/math.pi #Angle of total starting current(degree)\n",
+ "Power_factor = math.cos(I_t_angle*math.pi/180) #Power factor\n",
+ "#Case(b)\n",
+ "angle = (phi_I_rw-(-phi_I_sw)) #Angle between starting and running current(degree)\n",
+ "sin_angle = math.sin(angle*math.pi/180) #Sine of the angle between starting and running currents\n",
+ "#Case(c)\n",
+ "T_ratio = sin_angle/math.sin(25*math.pi/180) #Ratio of starting torque\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Total starting current , I_t = %.2f\u2220%.1f\u00b0 A' %(abs(I_t),I_t_angle))\n",
+ "print(' Power factor = %.3f ' %Power_factor)\n",
+ "print('Case(b): Sine of the angle between starting and running currents = %.4f ' %sin_angle)\n",
+ "print('Case(c): Steady state starting current has been reduced from 9.88\u2220-30\u00b0 A to %.2f\u2220%.1f\u00b0 A' %(abs(I_t),I_t_angle))\n",
+ "print(' The power factor has raised from 0.866 lagging to %.3f' %Power_factor)\n",
+ "print(' The ratio of starting torques , T_cs/T_rs = %.2f ' %T_ratio)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Total starting current , I_t = 7.66\u2220-8.9\u00b0 A\n",
+ " Power factor = 0.988 \n",
+ "Case(b): Sine of the angle between starting and running currents = 0.9903 \n",
+ "Case(c): Steady state starting current has been reduced from 9.88\u2220-30\u00b0 A to 7.66\u2220-8.9\u00b0 A\n",
+ " The power factor has raised from 0.866 lagging to 0.988\n",
+ " The ratio of starting torques , T_cs/T_rs = 2.34 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 10.4, Page number 345"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "T_r = 1.0 #Rated torque(lb-ft)\n",
+ "P_in = 400.0 #Rated input power(W)\n",
+ "V = 115.0 #Rated input voltage(V)\n",
+ "I_t = 5.35 #Rated input current(A)\n",
+ "Speed = 1750.0 #Rated speed(rpm)\n",
+ "hp = 1.0/3 #Rated hp\n",
+ "T_s = 4.5 #Starting torque(lb-ft) From Locked-Rotor data\n",
+ "T_br = 2.5 #Breakdown torque(lb-ft) From Breakdown-Torque data\n",
+ "\n",
+ "#Calculation\n",
+ "T_s_r = T_s/T_r #Ratio of starting to rated torque\n",
+ "T_br_r = T_br/T_r #Ratio of breakdown to rated torque\n",
+ "P_o = hp*746 #Power output(W) \n",
+ "n = P_o/P_in*100 #Rated load efficiency(%)\n",
+ "S = V*I_t #VA rating of the motor\n",
+ "cos_theta = P_in/S #Rated load power factor\n",
+ "hp = T_r*Speed/5252 #Rated load horsepower\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Ratio of starting to rated torque , T_s/T_r = %.1f ' %T_s_r)\n",
+ "print('Case(b): Ratio of breakdown to rated torque , T_br/T_r = %.1f ' %T_br_r)\n",
+ "print('Case(c): Rated load efficiency , \u03b7 = %.1f percent' %n)\n",
+ "print('Case(d): Rated load power factor , cos\u03b8 = %.4f ' %cos_theta)\n",
+ "print('Case(e): Rated load horsepower , hp = %.4f hp' %hp)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Ratio of starting to rated torque , T_s/T_r = 4.5 \n",
+ "Case(b): Ratio of breakdown to rated torque , T_br/T_r = 2.5 \n",
+ "Case(c): Rated load efficiency , \u03b7 = 62.2 percent\n",
+ "Case(d): Rated load power factor , cos\u03b8 = 0.6501 \n",
+ "Case(e): Rated load horsepower , hp = 0.3332 hp\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_11.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_11.ipynb new file mode 100755 index 00000000..3bf24fda --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_11.ipynb @@ -0,0 +1,243 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 11: SPECIALIZED DYNAMOS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 11.1, Page number 372"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "#Given Torque-Speed relations shown in Fig.11-3b page no-371 for a dc servomotor\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "S = 800.0 #Motor speed at point x(rpm). Extrapolating to load line point x\n",
+ "V = 60.0 #Armature voltage at point x(V)\n",
+ "#Case(b)\n",
+ "T = 4.5 #At standstill, 60 V yields 4.5 lb-ft of starting torque\n",
+ "#Case(c)\n",
+ "P_c = T*S/5252 #Power delivered to the load(hp). From case(a)\n",
+ "P_c_watt = P_c*746 #Power delivered to the load(W)\n",
+ "#Case(d)\n",
+ "T_d = 1.1 #Torque for continuous duty without cooling fan(lb-ft). At point o\n",
+ "S_d = 410.0 #Maximum load speed(rpm)\n",
+ "#Case(e)\n",
+ "T_e = 2.4 #Torque for continuous duty with cooling fan(lb-ft). At point w\n",
+ "S_e = 900.0 #Maximum load speed(rpm)\n",
+ "#Case(f)\n",
+ "P_d = T_d*S_d/5252 #Power delivered to the load(hp). From case(d)\n",
+ "P_d_watt = P_d*746 #Power delivered to the load(W)\n",
+ "#Case(g)\n",
+ "P_e = T_e*S_e/5252 #Power delivered to the load(hp). From case(e)\n",
+ "P_e_watt = P_e*746 #Power delivered to the load(W)\n",
+ "#Case(h)\n",
+ "A = 65.0 #Upper limit of power range A(W)\n",
+ "B = 305.0 #Upper limit of power range B(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Motor speed when load torque is 2.1 lb-ft at point x , S = %.f rpm' %S)\n",
+ "print(' Armature voltage when load torque is 2.1 lb-ft at point x , V = %.f V' %V)\n",
+ "print('Case(b): Motor starting torque using the voltage found in part(a) , T_st = %.1f lb-ft' %T)\n",
+ "print('Case(c): Power delivered to the load under conditions given in part(a) , P = %.3f hp = %.f W' %(P_c,P_c_watt))\n",
+ "print('Case(d): Maximum load speed for continuous duty without cooling fan , S = %.f rpm' %S_d)\n",
+ "print(' Torque for continuous duty without cooling fan , T = %.1f lb-ft' %T_d)\n",
+ "print('Case(e): Maximum load speed for continuous duty with cooling fan , S = %.f rpm' %S_e)\n",
+ "print(' Torque for continuous duty with cooling fan , T = %.1f lb-ft' %T_e)\n",
+ "print('Case(f): Power delivered to load in part(d) , P = %.4f hp = %.1f W' %(P_d,P_d_watt))\n",
+ "print('Case(g): Power delivered to load in part(e) , P = %.3f hp = %.f W' %(P_e,P_e_watt))\n",
+ "print('Case(h): Upper limit of power range , A = %.f W' %A)\n",
+ "print(' Upper limit of power range , B = %.f W' %B)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Motor speed when load torque is 2.1 lb-ft at point x , S = 800 rpm\n",
+ " Armature voltage when load torque is 2.1 lb-ft at point x , V = 60 V\n",
+ "Case(b): Motor starting torque using the voltage found in part(a) , T_st = 4.5 lb-ft\n",
+ "Case(c): Power delivered to the load under conditions given in part(a) , P = 0.685 hp = 511 W\n",
+ "Case(d): Maximum load speed for continuous duty without cooling fan , S = 410 rpm\n",
+ " Torque for continuous duty without cooling fan , T = 1.1 lb-ft\n",
+ "Case(e): Maximum load speed for continuous duty with cooling fan , S = 900 rpm\n",
+ " Torque for continuous duty with cooling fan , T = 2.4 lb-ft\n",
+ "Case(f): Power delivered to load in part(d) , P = 0.0859 hp = 64.1 W\n",
+ "Case(g): Power delivered to load in part(e) , P = 0.411 hp = 307 W\n",
+ "Case(h): Upper limit of power range , A = 65 W\n",
+ " Upper limit of power range , B = 305 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 11.2, Page number 379"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "n = 3.0 #Number of stacks or phases\n",
+ "P_a = 16.0 #Number of rotor teeth\n",
+ "P_b = 24.0 #Number of rotor poles\n",
+ "\n",
+ "#Calculation\n",
+ "alpha_a = 360/(n*P_a) #Stepping angle(degree/step) \n",
+ "alpha_b = 360/(n*P_b) #Stepping angle(degree/step)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Stepping angle , \u03b1 = %.1f\u00b0/step' %alpha_a)\n",
+ "print('Case(b): Stepping angle , \u03b1 = %.1f\u00b0/step' %alpha_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Stepping angle , \u03b1 = 7.5\u00b0/step\n",
+ "Case(b): Stepping angle , \u03b1 = 5.0\u00b0/step\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 11.3, Page number 381"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 50.0 #Number of rotor teeth\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = 90/P #Stepping length(degrees)\n",
+ "\n",
+ "#Result\n",
+ "print('\u03b1 = %.1f\u00b0 ' %alpha)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "\u03b1 = 1.8\u00b0 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 11.4, Page number 388"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "tou = 0.1 #Pole pitch of a double-sided primary LIM(m)\n",
+ "f = 60.0 #Frequency applied to the primary LIM(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "v_s = 2*f*tou #Synchronous velocity(m/s)\n",
+ "\n",
+ "#Result\n",
+ "print('Synchronous velocity , v_s = %.f m/s' %v_s)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Synchronous velocity , v_s = 12 m/s\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 11.5, Page number 388"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "v_s = 12.0 #Synchronous velocity(m/s)\n",
+ "v = 10.0 #Linear velocity of secondary sheet(m/s)\n",
+ "\n",
+ "#Calculation\n",
+ "s = (v_s-v)/v_s #Slip of the DSLIM\n",
+ "\n",
+ "#Result\n",
+ "print('Slip of the DSLIM , s = %.3f' %s)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Slip of the DSLIM , s = 0.167\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_12.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_12.ipynb new file mode 100755 index 00000000..429927d2 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_12.ipynb @@ -0,0 +1,1570 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 12: POWER, ENERGY, AND EFFICIENCY RELATIONS OF DC AND AC DYNAMOS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.1, Page number 412"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 10000.0 #Power rating of the shunt generator(W)\n",
+ "V = 230.0 #Voltage rating of the shunt generator(V)\n",
+ "S = 1750.0 #Speed of the shunt generator(rpm)\n",
+ "V_a = 245.0 #Voltage across armature(V)\n",
+ "I_a = 2.0 #Armature current(A)\n",
+ "R_f = 230.0 #Field resistance(ohm)\n",
+ "R_a = 0.2 #Armature resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "Rotational_loss = V_a*I_a-(I_a**2*R_a) #Rotational losses at full load(W) \n",
+ "#Case(b)\n",
+ "V_t = V\n",
+ "I_L = P/V_t #Line current(A)\n",
+ "I_f = V/R_f #Field current(A)\n",
+ "Ia = I_f+I_L #Armature current(A)\n",
+ "armature_loss = Ia**2*R_a #Full-load armature loss(W)\n",
+ "V_f = V\n",
+ "field_loss = V_f*I_f #Full-load field loss(W)\n",
+ "#Case(c)\n",
+ "n = P/(P+Rotational_loss+(armature_loss+field_loss))*100 #Efficiency of the generator at rated load(%) \n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rotational losses at full load , Rotational losses = %.1f W' %Rotational_loss)\n",
+ "print('Case(b): Full-load armature circuit loss , I_a^2*R_a = %.f W' %armature_loss)\n",
+ "print(' Field loss , V_f*I_f = %.f W' %field_loss)\n",
+ "print('Case(c): Efficiency of the generator at rated load , \u03b7 = %.1f percent' %n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rotational losses at full load , Rotational losses = 489.2 W\n",
+ "Case(b): Full-load armature circuit loss , I_a^2*R_a = 396 W\n",
+ " Field loss , V_f*I_f = 230 W\n",
+ "Case(c): Efficiency of the generator at rated load , \u03b7 = 90.0 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.2, Page number 412"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 10000.0 #Power rating of the shunt generator(W)\n",
+ "Rotational_loss = 489.2 #Rotational loss at full load(W)\n",
+ "armature_loss = 396.0 #Full-load armature loss(W)\n",
+ "field_loss = 230.0 #Full-load field loss(W)\n",
+ "x1 = 1.0/4 #Fraction of full-load\n",
+ "x2 = 1.0/2 #Fraction of full-load\n",
+ "x3 = 3.0/4 #Fraction of full-load\n",
+ "x4 = 5.0/4 #Fraction of full-load\n",
+ "\n",
+ "#Calculation\n",
+ "n_a = (P*x1)/((P*x1)+Rotational_loss+(armature_loss*(x1**2)+field_loss))*100 #Efficiency of generator(%)\n",
+ "n_b = (P*x2)/((P*x2)+Rotational_loss+(armature_loss*(x2**2)+field_loss))*100 #Efficiency of generator(%)\n",
+ "n_c = (P*x3)/((P*x3)+Rotational_loss+(armature_loss*(x3**2)+field_loss))*100 #Efficiency of generator(%)\n",
+ "n_d = (P*x4)/((P*x4)+Rotational_loss+(armature_loss*(x4**2)+field_loss))*100 #Efficiency of generator(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Efficiency of the generator at 1/4 load , \u03b7 = %.1f percent' %n_a)\n",
+ "print('Case(b): Efficiency of the generator at 1/2 load , \u03b7 = %.1f percent' %n_b)\n",
+ "print('Case(c): Efficiency of the generator at 3/4 load , \u03b7 = %.1f percent' %n_c)\n",
+ "print('Case(d): Efficiency of the generator at 5/4 load , \u03b7 = %.1f percent' %n_d)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Efficiency of the generator at 1/4 load , \u03b7 = 77.1 percent\n",
+ "Case(b): Efficiency of the generator at 1/2 load , \u03b7 = 85.9 percent\n",
+ "Case(c): Efficiency of the generator at 3/4 load , \u03b7 = 88.8 percent\n",
+ "Case(d): Efficiency of the generator at 5/4 load , \u03b7 = 90.3 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.3, Page number 413"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 240.0 #Voltage rating of the dc shunt motor(V)\n",
+ "hp = 25.0 #Power rating of the dc shunt motor(hp)\n",
+ "S = 1800.0 #Speed of the shunt generator(rpm)\n",
+ "I_L = 89.0 #Full-load line current(A)\n",
+ "R_a = 0.05 #Armature resistance(ohm)\n",
+ "R_f = 120.0 #Field circuit resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_f = V #Field voltage(V)\n",
+ "I_f = V_f/R_f #Field current(A)\n",
+ "I_a = I_L-I_f #Armature current(A)\n",
+ "V_a = V\n",
+ "E_c = V_a-I_a*R_a #Armature voltage to be applied to the motor(V)\n",
+ "#Case(b)\n",
+ "Ia = 4.2 #Armature current produced by E_c(A)\n",
+ "Va = E_c #Armature voltage(V)\n",
+ "P_r = Va*Ia #Stray power(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Armature voltage to be applied to the motor when motor is run light at 1800 rpm during stray power test , E_c = %.2f V' %E_c)\n",
+ "print('Case(b): Stray power when voltage in part(a) produces an armature current of 4.2 A at 1800 rpm , P_r = %.1f W' %P_r)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Armature voltage to be applied to the motor when motor is run light at 1800 rpm during stray power test , E_c = 235.65 V\n",
+ "Case(b): Stray power when voltage in part(a) produces an armature current of 4.2 A at 1800 rpm , P_r = 989.7 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.4, Page number 415"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 600.0 #Voltage rating of the compound motor(V)\n",
+ "hp = 150.0 #Power rating of the compound motor(hp)\n",
+ "I_L = 205.0 #Full-load rated line current(A)\n",
+ "S = 1500.0 #Full-load speed of the compound generator(rpm)\n",
+ "R_sh = 300.0 #Shunt field resistance(ohm)\n",
+ "R_a = 0.05 #Armature resistance(ohm)\n",
+ "R_s = 0.1 #Series field resistance(ohm)\n",
+ "V_a = 570.0 #Applied voltage(V)\n",
+ "I_a = 6.0 #Armature current(A)\n",
+ "S_o = 1800.0 #No-load speed of the compound generator(rpm)\n",
+ "x1 = 1.0/4 #Fraction of full-load\n",
+ "x2 = 1.0/2 #Fraction of full-load\n",
+ "x3 = 3.0/4 #Fraction of full-load\n",
+ "x4 = 5.0/4 #Fraction of full-load\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "Rot_losses = V_a*I_a #Rotational loss(W)\n",
+ "S_1 = S_o-300*x1 #Speed at 1/4 load(rpm)\n",
+ "Rot_losses_S_1 = (S_1/S)*Rot_losses #Rotational loss at speed S_1(W)\n",
+ "S_2 = S_o-300*x2 #Speed at 1/2 load(rpm)\n",
+ "Rot_losses_S_2 = (S_2/S)*Rot_losses #Rotational loss at speed S_2(W)\n",
+ "S_3 = S_o-300*x3 #Speed at 3/4 load(rpm)\n",
+ "Rot_losses_S_3 = (S_3/S)*Rot_losses #Rotational loss at speed S_3(W)\n",
+ "S_4 = S_o-300*x4 #Speed at 5/4 load(rpm)\n",
+ "Rot_losses_S_4 = (S_4/S)*Rot_losses #Rotational loss at speed S_4(W)\n",
+ "#Case(b)\n",
+ "I_sh = V/R_sh #Full-load shunt field current(A)\n",
+ "Ia = I_L-I_sh #Full-load armature current(A)\n",
+ "FL_variable_loss = Ia**2*(R_a+R_s) #Full-load variable electric loss(W)\n",
+ "x1_variable_loss = FL_variable_loss*x1**2 #Variable losses at 1/4 load(W)\n",
+ "x2_variable_loss = FL_variable_loss*x2**2 #Variable losses at 1/2 load(W)\n",
+ "x3_variable_loss = FL_variable_loss*x3**2 #Variable losses at 3/4 load(W)\n",
+ "x4_variable_loss = FL_variable_loss*x4**2 #Variable losses at 5/4 load(W)\n",
+ "#Case(c)\n",
+ "Input_FL = V*I_L #Input at full load(W)\n",
+ "Input_x1 = V*I_L*x1 #Input at 1/4 load(W)\n",
+ "Input_x2 = V*I_L*x2 #Input at 1/2 load(W)\n",
+ "Input_x3 = V*I_L*x3 #Input at 3/4 load(W)\n",
+ "Input_x4 = V*I_L*x4 #Input at 5/4 load(W)\n",
+ "Field_loss = V*I_sh #Field loss for each of the conditions of load(W)\n",
+ "Losses_FL = Field_loss+Rot_losses+FL_variable_loss #Total losses for full load(W)\n",
+ "Losses_1 = Field_loss+Rot_losses_S_1+x1_variable_loss #Total losses for 1/4 load(W)\n",
+ "Losses_2 = Field_loss+Rot_losses_S_2+x2_variable_loss #Total losses for 1/2 load(W)\n",
+ "Losses_3 = Field_loss+Rot_losses_S_3+x3_variable_loss #Total losses for 3/4 load(W)\n",
+ "Losses_4 = Field_loss+Rot_losses_S_4+x4_variable_loss #Total losses for 5/4 load(W)\n",
+ "n_FL = (Input_FL-Losses_FL)/Input_FL*100 #Efficiency for full load(%)\n",
+ "n_1 = (Input_x1-Losses_1)/Input_x1*100 #Efficiency for 1/4 load(%)\n",
+ "n_2 = (Input_x2-Losses_2)/Input_x2*100 #Efficiency for 1/2 load(%)\n",
+ "n_3 = (Input_x3-Losses_3)/Input_x3*100 #Efficiency for 3/4 load(%)\n",
+ "n_4 = (Input_x4-Losses_4)/Input_x4*100 #Efficiency for 5/4 load(%) \n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rotational loss at full load = %.f W' %Rot_losses)\n",
+ "print(' Rotational loss at 1/4 times rated load = %.f W' %Rot_losses_S_1)\n",
+ "print(' Rotational loss at 1/2 times rated load = %.f W' %Rot_losses_S_2)\n",
+ "print(' Rotational loss at 3/4 times rated load = %.f W' %Rot_losses_S_3)\n",
+ "print(' Rotational loss at 5/4 times rated load = %.f W' %Rot_losses_S_4)\n",
+ "print('Case(b): Full-load variable electric losses = %.f W' %FL_variable_loss)\n",
+ "print(' Variable electric losses at 1/4 load = %.f W' %x1_variable_loss)\n",
+ "print(' Variable electric losses at 1/2 load = %.f W' %x2_variable_loss)\n",
+ "print(' Variable electric losses at 3/4 load = %.f W' %x3_variable_loss)\n",
+ "print(' Variable electric losses at 5/4 load = %.f W' %x4_variable_loss)\n",
+ "print('Case(c): Efficiency of motor at full load = %.1f percent' %n_FL)\n",
+ "print(' Efficiency of motor at 1/4 load = %.1f percent' %n_1)\n",
+ "print(' Efficiency of motor at 1/2 load = %.1f percent' %n_2)\n",
+ "print(' Efficiency of motor at 3/4 load = %.1f percent' %n_3)\n",
+ "print(' Efficiency of motor at 5/4 load = %.1f percent' %n_4)\n",
+ "print('Case(d): Table 12-2 Losses and Efficiencies for Ex. 12-4')\n",
+ "print('______________________________________________________________________________________________________________')\n",
+ "print('\\t Item \\t\\t\\t At 1/4 load \\t At 1/2 load \\t At 3/4 load \\t At Full load \\t At 5/4 load')\n",
+ "print('______________________________________________________________________________________________________________')\n",
+ "print('Input(watts)\\t\\t\\t %d \\t\\t %d \\t\\t %d \\t\\t %d \\t\\t %d' %(Input_x1,Input_x2,Input_x3,Input_FL,Input_x4))\n",
+ "print('Field loss(watts)\\t\\t %d \\t\\t %d \\t\\t %d \\t\\t %d \\t\\t %d' %(Field_loss,Field_loss,Field_loss,Field_loss,Field_loss))\n",
+ "print('Rotational losses,')\n",
+ "print(' From part(a) (watts)\\t\\t %d \\t\\t %d \\t\\t %d \\t\\t %d \\t\\t %d' %(Rot_losses_S_1,Rot_losses_S_2,Rot_losses_S_3,Rot_losses,Rot_losses_S_4))\n",
+ "print('Variable electric losses,')\n",
+ "print(' From part(b) (watts)\\t\\t %d \\t\\t %d \\t\\t %d \\t\\t %d \\t\\t %d' %(x1_variable_loss,x2_variable_loss,x3_variable_loss,FL_variable_loss,x4_variable_loss))\n",
+ "print('Total of all losses(watts)\\t %d \\t\\t %d \\t\\t %d \\t\\t %d \\t\\t %d' %(Losses_1,Losses_2,Losses_3,Losses_FL,Losses_4))\n",
+ "print('______________________________________________________________________________________________________________')\n",
+ "print('Efficiency \u03b7(percent)\\t\\t %.1f \\t\\t %.1f \\t\\t %.1f \\t\\t %.1f \\t\\t %.1f' %(n_1,n_2,n_3,n_FL,n_4))\n",
+ "print('______________________________________________________________________________________________________________')\n",
+ "print('\\nNOTE: Changes in obtained answer from that of textbook is due to more precision')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rotational loss at full load = 3420 W\n",
+ " Rotational loss at 1/4 times rated load = 3933 W\n",
+ " Rotational loss at 1/2 times rated load = 3762 W\n",
+ " Rotational loss at 3/4 times rated load = 3591 W\n",
+ " Rotational loss at 5/4 times rated load = 3249 W\n",
+ "Case(b): Full-load variable electric losses = 6181 W\n",
+ " Variable electric losses at 1/4 load = 386 W\n",
+ " Variable electric losses at 1/2 load = 1545 W\n",
+ " Variable electric losses at 3/4 load = 3477 W\n",
+ " Variable electric losses at 5/4 load = 9658 W\n",
+ "Case(c): Efficiency of motor at full load = 91.2 percent\n",
+ " Efficiency of motor at 1/4 load = 82.1 percent\n",
+ " Efficiency of motor at 1/2 load = 89.4 percent\n",
+ " Efficiency of motor at 3/4 load = 91.0 percent\n",
+ " Efficiency of motor at 5/4 load = 90.8 percent\n",
+ "Case(d): Table 12-2 Losses and Efficiencies for Ex. 12-4\n",
+ "______________________________________________________________________________________________________________\n",
+ "\t Item \t\t\t At 1/4 load \t At 1/2 load \t At 3/4 load \t At Full load \t At 5/4 load\n",
+ "______________________________________________________________________________________________________________\n",
+ "Input(watts)\t\t\t 30750 \t\t 61500 \t\t 92250 \t\t 123000 \t\t 153750\n",
+ "Field loss(watts)\t\t 1200 \t\t 1200 \t\t 1200 \t\t 1200 \t\t 1200\n",
+ "Rotational losses,\n",
+ " From part(a) (watts)\t\t 3932 \t\t 3762 \t\t 3591 \t\t 3420 \t\t 3249\n",
+ "Variable electric losses,\n",
+ " From part(b) (watts)\t\t 386 \t\t 1545 \t\t 3477 \t\t 6181 \t\t 9658\n",
+ "Total of all losses(watts)\t 5519 \t\t 6507 \t\t 8268 \t\t 10801 \t\t 14107\n",
+ "______________________________________________________________________________________________________________\n",
+ "Efficiency \u03b7(percent)\t\t 82.1 \t\t 89.4 \t\t 91.0 \t\t 91.2 \t\t 90.8\n",
+ "______________________________________________________________________________________________________________\n",
+ "\n",
+ "NOTE: Changes in obtained answer from that of textbook is due to more precision\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.5, Page number 415"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 10000.0 #Power rating of the shunt generator(W)\n",
+ "V = 230.0 #Voltage rating of the shunt generator(V)\n",
+ "S = 1750.0 #Speed of the shunt generator(rpm)\n",
+ "V_a = 245.0 #Voltage across armature(V)\n",
+ "I_a = 2.0 #Armature current(A)\n",
+ "R_a = 0.2 #Armature resistance(ohm)\n",
+ "P_r = 489.2 #Shunt generator rotational losses(W)\n",
+ "Vf_If = 230.0 #Shunt field circuit loss(W)\n",
+ "I_a_rated = 44.5 #Rated armature current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "I_a = ((Vf_If+P_r)/R_a)**0.5 #Armature current at which max efficiency occurs(A)\n",
+ "LF = I_a/I_a_rated #Load fraction\n",
+ "LF_percent = LF*100 #Load fraction(%)\n",
+ "P_k = Vf_If+P_r\n",
+ "n_max = P*LF/(P*LF+(Vf_If+P_r)+P_k)*100 #Maximum efficiency(%)\n",
+ "LF_d = (P_k/(I_a_rated**2*R_a))**0.5 #Load fraction from fixed losses and rated variable losses\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Armature current at which maximum efficiency occurs , I_a = %.f A' %I_a)\n",
+ "print('Case(b): Load fraction , L.F = %.1f percent = %.3f*rated' %(LF_percent,LF))\n",
+ "print('Case(c): Maximum efiiciency , \u03b7_max = %.2f percent' %n_max)\n",
+ "print('Case(d): Load fraction from fixed losses and rated variable losses , L.F = %.3f*rated' %LF_d)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Armature current at which maximum efficiency occurs , I_a = 60 A\n",
+ "Case(b): Load fraction , L.F = 134.8 percent = 1.348*rated\n",
+ "Case(c): Maximum efiiciency , \u03b7_max = 90.36 percent\n",
+ "Case(d): Load fraction from fixed losses and rated variable losses , L.F = 1.348*rated\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.6, Page number 418"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 240.0 #Voltage rating of dc shunt motor(V)\n",
+ "hp = 25.0 #Power rating of dc shunt motor(hp)\n",
+ "S = 1100.0 #Speed of the dc shunt motor(rpm)\n",
+ "R_a = 0.15 #Armture resistance(ohm)\n",
+ "R_f = 80.0 #Field resistance(ohm)\n",
+ "I_L = 89.0 #Rated line current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "V_f = V #Voltage across field winding(V)\n",
+ "I_f = V_f/R_f #Field current(A)\n",
+ "I_a = I_L-I_f #Armature current(A)\n",
+ "P_o = hp*746 #Power rating of dc shunt motor(W)\n",
+ "V_a = V #Voltage across armature(V)\n",
+ "E_c_fl = V_a-I_a*R_a #Back EMF(V)\n",
+ "E_c = E_c_fl\n",
+ "P_d = E_c*I_a #Power developed by the armature(W)\n",
+ "P_r = P_d-P_o #Full-load rotational losses(W)\n",
+ "P_in = V*I_L #Input power(W)\n",
+ "n = P_o/P_in*100 #Full-load efficiency(%) \n",
+ "P_k = V_f*I_f+P_r #Total constant losses(W)\n",
+ "Ia = (P_k/R_a)**0.5 #Armature current for maximum efficiency(A)\n",
+ "I_a_rated = I_a\n",
+ "LF = Ia/I_a_rated #Load fraction at which max efficiency is produced\n",
+ "rated_input = V*I_L \n",
+ "n_max = ((LF*rated_input)-2*P_k)/(LF*rated_input)*100 #Maximum efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Power developed by the armature , P_d = %.1f W' %P_d)\n",
+ "print('Case(b): Full-load rotational losses , P_r = %.1f W' %P_r)\n",
+ "print('Case(c): Full-laod efficiency , \u03b7 = %.1f percent' %n)\n",
+ "print('Case(d): Total constant losses , P_k = %.1f W' %P_k)\n",
+ "print('Case(e): Armature current from maximum efficiency , I_a = %.1f A' %Ia)\n",
+ "print('Case(f): Load fraction at which maximum efficiency is produced , L.F = %.1f ' %LF)\n",
+ "print('Case(g): Maximum efficiency , \u03b7_max = %.1f percent' %n_max)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Power developed by the armature , P_d = 19530.6 W\n",
+ "Case(b): Full-load rotational losses , P_r = 880.6 W\n",
+ "Case(c): Full-laod efficiency , \u03b7 = 87.3 percent\n",
+ "Case(d): Total constant losses , P_k = 1600.6 W\n",
+ "Case(e): Armature current from maximum efficiency , I_a = 103.3 A\n",
+ "Case(f): Load fraction at which maximum efficiency is produced , L.F = 1.2 \n",
+ "Case(g): Maximum efficiency , \u03b7_max = 87.5 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.7, Page number 420"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 240.0 #Voltage rating of dc shunt motor(V)\n",
+ "hp = 25.0 #Power rating of dc shunt motor(hp)\n",
+ "S = 1100.0 #Speed of the dc shunt motor(rpm)\n",
+ "R_a = 0.15 #Armture resistance(ohm)\n",
+ "R_f = 80.0 #Field resistance(ohm)\n",
+ "I_L = 89.0 #Rated line current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "V_f = V #Voltage across field winding(V)\n",
+ "I_f = V_f/R_f #Field current(A)\n",
+ "I_a = I_L-I_f #Armature current(A)\n",
+ "P_o = hp*746 #Power rating of dc shunt motor(W)\n",
+ "V_a = V #Voltage across armature(V)\n",
+ "E_c_fl = V_a-I_a*R_a #Back EMF(V)\n",
+ "E_c = E_c_fl\n",
+ "P_d = E_c*I_a #Power developed by the armature(W)\n",
+ "P_r = P_d-P_o #Full-load rotational losses(W)\n",
+ "P_in = V*I_L #Input power(W)\n",
+ "n = P_o/P_in*100 #Full-load efficiency(%) \n",
+ "P_k = V_f*I_f+P_r #Total constant losses(W)\n",
+ "Ia = (P_k/R_a)**0.5 #Armature current for maximum efficiency(A)\n",
+ "I_a_rated = I_a\n",
+ "LF = Ia/I_a_rated #Load fraction at which max efficiency is produced\n",
+ "rated_input = V*I_L \n",
+ "n_max = ((LF*rated_input)-2*P_k)/(LF*rated_input)*100 #Maximum efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Power developed by the armature , P_d = %.1f W' %P_d)\n",
+ "print('Case(b): Full-load rotational losses , P_r = %.1f W' %P_r)\n",
+ "print('Case(c): Full-laod efficiency , \u03b7 = %.1f percent' %n)\n",
+ "print('Case(d): Total constant losses , P_k = %.1f W' %P_k)\n",
+ "print('Case(e): Armature current from maximum efficiency , I_a = %.1f A' %Ia)\n",
+ "print('Case(f): Load fraction at which maximum efficiency is produced , L.F = %.1f ' %LF)\n",
+ "print('Case(g): Maximum efficiency , \u03b7_max = %.1f percent' %n_max)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Power developed by the armature , P_d = 19530.6 W\n",
+ "Case(b): Full-load rotational losses , P_r = 880.6 W\n",
+ "Case(c): Full-laod efficiency , \u03b7 = 87.3 percent\n",
+ "Case(d): Total constant losses , P_k = 1600.6 W\n",
+ "Case(e): Armature current from maximum efficiency , I_a = 103.3 A\n",
+ "Case(f): Load fraction at which maximum efficiency is produced , L.F = 1.2 \n",
+ "Case(g): Maximum efficiency , \u03b7_max = 87.5 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.8, Page number 420"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 240.0 #Voltage rating of dc shunt motor(V)\n",
+ "hp = 5.0 #Power rating of dc shunt motor(hp)\n",
+ "S_fl = 1100.0 #Speed of the dc shunt motor(rpm)\n",
+ "R_a = 0.4 #Armture resistance(ohm)\n",
+ "R_f = 240.0 #Field resistance(ohm)\n",
+ "n = 0.75 #Full-load efficiency\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_L = V #Load voltage(V)\n",
+ "P_o = hp*746 #Power rating of dc shunt motor(W)\n",
+ "I_L = P_o/(n*V_L) #Rated input line current(A)\n",
+ "V_f = V #Voltage across field winding(V)\n",
+ "I_f = V_f/R_f #Field current(A)\n",
+ "I_a = I_L-I_f #Armature current(A)\n",
+ "#Case(b)\n",
+ "V_a = V #Voltage across armature(V)\n",
+ "E_c_fl = V_a-I_a*R_a #Back EMF(V)\n",
+ "E_c = E_c_fl\n",
+ "P_d = E_c*I_a #Power developed in the armature at rated load(W)\n",
+ "#Case(c)\n",
+ "P_r = P_d-P_o #Rotational losses at rated load(W)\n",
+ "#Case(d)\n",
+ "P_o_nl = 0 #At no-load\n",
+ "P_r_nl = P_r #Rotational losses at no load(W)\n",
+ "P_d_nl = P_r_nl\n",
+ "#Case(e)\n",
+ "I_a_nl = P_d_nl/V_a #No-load armature current(A)\n",
+ "#Case(f)\n",
+ "E_c_nl = V #No-load voltage(V)\n",
+ "E_c_fl = E_c #Full-load voltage(V)\n",
+ "S_nl = E_c_nl/E_c_fl*S_fl #No-load speed(rpm)\n",
+ "#Case(g)\n",
+ "SR = (S_nl-S_fl)/S_fl*100 #Speed regulation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rated input line current , I_L = %.2f A' %I_L)\n",
+ "print(' Rated armature current , I_a = %.2f A' %I_a)\n",
+ "print('Case(b): Power developed in the armature at rated load , P_d = %d W' %P_d)\n",
+ "print('Case(c): Rotational losses at rated load , P_r = %d W' %P_r)\n",
+ "print('Case(d): Rotational losses at no load , P_r = %d W' %P_r_nl)\n",
+ "print('Case(e): No-load armature current , I_a(nl) = %.2f A' %I_a_nl)\n",
+ "print('Case(f): No-load speed , S_nl = %.f rpm' %S_nl)\n",
+ "print('Case(g): Speed regulation of the motor , SR = %.1f percent' %SR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rated input line current , I_L = 20.72 A\n",
+ " Rated armature current , I_a = 19.72 A\n",
+ "Case(b): Power developed in the armature at rated load , P_d = 4577 W\n",
+ "Case(c): Rotational losses at rated load , P_r = 847 W\n",
+ "Case(d): Rotational losses at no load , P_r = 847 W\n",
+ "Case(e): No-load armature current , I_a(nl) = 3.53 A\n",
+ "Case(f): No-load speed , S_nl = 1137 rpm\n",
+ "Case(g): Speed regulation of the motor , SR = 3.4 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.9, Page number 421"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 240.0 #Voltage rating of dc shunt motor(V)\n",
+ "I_L = 55.0 #Rated line current(A) \n",
+ "S = 1200.0 #Speed of the dc shunt motor(rpm)\n",
+ "P_r = 406.4 #Rotational losses at rated load(W)\n",
+ "R_f = 120.0 #Field resistance(ohm)\n",
+ "R_a = 0.4 #Armture resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_f = V #Voltage across field winding(V)\n",
+ "I_f = V_f/R_f #Field current(A)\n",
+ "I_a = I_L-I_f #Armature current(A)\n",
+ "V_a = V #Voltage across armature(V)\n",
+ "E_c = V_a-I_a*R_a #Back EMF(V)\n",
+ "P_d = E_c*I_a #Power developed by the armature at rated load(W)\n",
+ "#Case(b)\n",
+ "P_o = P_d-P_r #Rated output power(W)\n",
+ "P_o_hp = P_o/746 #Rated output power(hp)\n",
+ "#Case(c)\n",
+ "T_o = P_o_hp*5252/S #Rated output torque(lb-ft)\n",
+ "T_o_Nm = T_o*1.356 #Rated output torque(N-m)\n",
+ "#Case(d)\n",
+ "P_in = V*I_L #Input power(W)\n",
+ "n = (P_o/P_in)*100 #Efficiency at rated load(%)\n",
+ "#Case(e)\n",
+ "P_o_nl = 0 #At no-load\n",
+ "P_r_nl = P_r #Rotational losses at no load(W)\n",
+ "P_d_nl = P_r_nl\n",
+ "I_a_nl = P_r_nl/V_a #No-load armature current(A)\n",
+ "E_c_nl = V #No-load voltage(V)\n",
+ "E_c_fl = E_c #Full-load voltage(V)\n",
+ "S_fl = S #Full-load speed(rpm)\n",
+ "S_nl = E_c_nl/E_c_fl*S_fl #No-load speed(rpm)\n",
+ "#Case(f)\n",
+ "SR = (S_nl-S_fl)/S_fl*100 #Speed regulation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Counter EMF , E_c = %.1f V' %E_c)\n",
+ "print(' Power developed at rated load , P_d = %.1f W' %P_d)\n",
+ "print('Case(b): Rated output power , P_o = %d W' %P_o)\n",
+ "print(' Rated output power , P_o = %d hp' %P_o_hp)\n",
+ "print('Case(c): Rated output torque , T_o = %.2f lb-ft' %T_o)\n",
+ "print(' Rated output torque , T_o = %d N-m' %T_o_Nm)\n",
+ "print('Case(d): Efficiency at rated load , \u03b7 = %.1f percent' %n)\n",
+ "print('Case(e): No-load armature current , I_a(nl) = %.3f A' %I_a_nl)\n",
+ "print(' No-load speed , S_nl = %.f rpm' %S_nl)\n",
+ "print('Case(e): Speed regulation , SR = %.1f percent' %SR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Counter EMF , E_c = 218.8 V\n",
+ " Power developed at rated load , P_d = 11596.4 W\n",
+ "Case(b): Rated output power , P_o = 11190 W\n",
+ " Rated output power , P_o = 15 hp\n",
+ "Case(c): Rated output torque , T_o = 65.65 lb-ft\n",
+ " Rated output torque , T_o = 89 N-m\n",
+ "Case(d): Efficiency at rated load , \u03b7 = 84.8 percent\n",
+ "Case(e): No-load armature current , I_a(nl) = 1.693 A\n",
+ " No-load speed , S_nl = 1316 rpm\n",
+ "Case(e): Speed regulation , SR = 9.7 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.10, Page number 422"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 125.0 #Voltage rating of generator(V)\n",
+ "P_o = 12500.0 #Power rating of generator(W)\n",
+ "P_hp = 20.0 #Power rating of motor(hp)\n",
+ "R_a = 0.1 #Armature resistance(ohm)\n",
+ "R_f = 62.5 #Field resistance(ohm)\n",
+ "P_var = 1040.0 #Rated variable electric loss(W)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "P_in = P_hp*746 #Power input to generator(W)\n",
+ "n = P_o/P_in*100 #Efficiency(%)\n",
+ "#Case(b)\n",
+ "V_f = V #Voltage across shunt field winding(V)\n",
+ "P_sh_loss = V_f**2/R_f #Shunt field loss(W)\n",
+ "#Case(c)\n",
+ "V_L = V\n",
+ "I_L = P_o/V_L #Line current(A)\n",
+ "I_f = V_f/R_f #Field current(A)\n",
+ "I_a = I_L+I_f #Armature current(A)\n",
+ "E_g = V_L+I_a*R_a #Generated EMF(V)\n",
+ "P_d1 = E_g*I_a #Generated electric power(W)\n",
+ "P_f = V_f*I_f\n",
+ "P_d2 = P_o+P_var+P_f #Generated electric power(W)\n",
+ "#Case(d)\n",
+ "P_d = P_d1\n",
+ "P_r = P_in-P_d #Rotational power loss(W)\n",
+ "#Case(e)\n",
+ "P_k = P_r+V_f*I_f #Constant losses(W)\n",
+ "Ia = (P_k/R_a)**0.5 #Armature current for max efficiency(A)\n",
+ "#Case(f)\n",
+ "I_a_rated = I_a #Rated armature current(A)\n",
+ "LF = Ia/I_a_rated #Load fraction\n",
+ "#Case(g)\n",
+ "rated_output = 12500 #Rated output(W)\n",
+ "n_max = (LF*rated_output)/((LF*rated_output)+(2*P_k))*100 #Maximum efficiency\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Efficiency , \u03b7 = %.f percent' %n)\n",
+ "print('Case(b): Shunt field loss = %d W' %P_sh_loss)\n",
+ "print('Case(c): Generated electric power , P_d = %d W (Method 1)' %P_d1)\n",
+ "print(' Generated electric power , P_d = %d W (Method 2)' %P_d2)\n",
+ "print('Case(d): Rotational power loss , P_r = %.f W' %P_r)\n",
+ "print('Case(e): Armature current for maximum efficiency , I_a = %.1f A' %Ia)\n",
+ "print('Case(f): Load fraction for maximum efficiency , L.F = %.2f ' %LF)\n",
+ "print('Case(g): Maximum efficiency , \u03b7 = %.2f percent' %n_max)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Efficiency , \u03b7 = 84 percent\n",
+ "Case(b): Shunt field loss = 250 W\n",
+ "Case(c): Generated electric power , P_d = 13790 W (Method 1)\n",
+ " Generated electric power , P_d = 13790 W (Method 2)\n",
+ "Case(d): Rotational power loss , P_r = 1130 W\n",
+ "Case(e): Armature current for maximum efficiency , I_a = 117.5 A\n",
+ "Case(f): Load fraction for maximum efficiency , L.F = 1.15 \n",
+ "Case(g): Maximum efficiency , \u03b7 = 83.91 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.11, Page number 422"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 125.0 #Voltage rating of generator(V)\n",
+ "P_o = 12500.0 #Power rating of generator(W)\n",
+ "P_hp = 20.0 #Power rating of motor(hp)\n",
+ "R_a = 0.1 #Armature resistance(ohm)\n",
+ "R_f = 62.5 #Field resistance(ohm)\n",
+ "P_var = 1040.0 #Rated variable electric loss(W)\n",
+ "P_k = 1380.0 #Constant losses(W)\n",
+ "LF_a = 25.0/100 #At rated output\n",
+ "LF_b = 50.0/100 #At rated output\n",
+ "LF_c = 75.0/100 #At rated output\n",
+ "LF_d = 125.0/100 #At rated output\n",
+ "\n",
+ "#Calculation\n",
+ "output = P_o\n",
+ "P_a_rated = P_var\n",
+ "n_a = output*LF_a/(output*LF_a+P_k+(LF_a**2)*P_a_rated)*100 #Efficiency of dc shunt generator(%)\n",
+ "n_b = output*LF_b/(output*LF_b+P_k+(LF_b**2)*P_a_rated)*100 #Efficiency of dc shunt generator(%)\n",
+ "n_c = output*LF_c/(output*LF_c+P_k+(LF_c**2)*P_a_rated)*100 #Efficiency of dc shunt generator(%)\n",
+ "n_d = output*LF_d/(output*LF_d+P_k+(LF_d**2)*P_a_rated)*100 #Efficiency of dc shunt generator(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Efficiency of dc generator at 25 percent rated output , \u03b7 = %.1f percent' %n_a)\n",
+ "print('Case(b): Efficiency of dc generator at 50 percent rated output , \u03b7 = %.1f percent' %n_b)\n",
+ "print('Case(c): Efficiency of dc generator at 75 percent rated output , \u03b7 = %.1f percent' %n_c)\n",
+ "print('Case(d): Efficiency of dc generator at 125 percent rated output , \u03b7 = %.2f percent' %n_d)\n",
+ "print('\\nNOTE: Calculation error in textbook for case(b)')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Efficiency of dc generator at 25 percent rated output , \u03b7 = 68.4 percent\n",
+ "Case(b): Efficiency of dc generator at 50 percent rated output , \u03b7 = 79.2 percent\n",
+ "Case(c): Efficiency of dc generator at 75 percent rated output , \u03b7 = 82.7 percent\n",
+ "Case(d): Efficiency of dc generator at 125 percent rated output , \u03b7 = 83.87 percent\n",
+ "\n",
+ "NOTE: Calculation error in textbook for case(b)\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.12, Page number 426"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 100.0 #Rating of the alternator(kVA)\n",
+ "V = 1100.0 #Rated voltage of the alternator(V)\n",
+ "I_a_nl = 8.0 #No-load armature current(A)\n",
+ "P_in_nl = 6000.0 #No-load Power input to the armature(W)\n",
+ "V_oc = 1350.0 #Open-circuit line voltage(V)\n",
+ "I_f = 18.0 #Field current(A)\n",
+ "V_f = 125.0 #Voltage across field winding(V)\n",
+ "R_a = 0.45 #Armature resistance(ohm/phase)\n",
+ "I_a_rated = 52.5 #Rated armature current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "P_r = P_in_nl-3*(I_a_nl)**2*R_a #Rotational loss of synchronous dynamo(W)\n",
+ "#Case(b)\n",
+ "P_f = V_f*I_f #Field copper loss(W)\n",
+ "#Case(c)\n",
+ "P_k = P_r+P_f #Fixed losses at rated synchronous speed(W)\n",
+ "#Case(d)\n",
+ "P_cu = 3*(I_a_rated)**2*R_a #Electric armature copper loss at rated load(W)\n",
+ "LF1 = 1.0/4 #Load fraction\n",
+ "LF2 = 1.0/2 #Load fraction\n",
+ "LF3 = 3.0/4 #Load fraction\n",
+ "P_cu_LF1 = P_cu*(LF1)**2 #Electric armature copper loss at 1/4 load(W)\n",
+ "P_cu_LF2 = P_cu*(LF2)**2 #Electric armature copper loss at 1/2 load(W)\n",
+ "P_cu_LF3 = P_cu*(LF3)**2 #Electric armature copper loss at 3/4 load(W)\n",
+ "#Case(e)\n",
+ "PF = 0.9 #Power factor lagging\n",
+ "n_1 = (LF1*kVA*1000*PF)/((LF1*kVA*1000*PF)+P_k+P_cu_LF1)*100 #Efficiency at 1/4 load\n",
+ "n_2 = (LF2*kVA*1000*PF)/((LF2*kVA*1000*PF)+P_k+P_cu_LF2)*100 #Efficiency at 1/2 load\n",
+ "n_3 = (LF3*kVA*1000*PF)/((LF3*kVA*1000*PF)+P_k+P_cu_LF3)*100 #Efficiency at 3/4 load\n",
+ "n_fl = (kVA*1000*PF)/((kVA*1000*PF)+P_k+P_cu)*100 #Efficiency at rated load\n",
+ "#Case(f)\n",
+ "I_a_max = (P_k/(3*R_a))**0.5 #Armature current for max efficiency at 0.9 PF lagging(A)\n",
+ "LF = I_a_max/I_a_rated #Load fraction for max efficiency\n",
+ "n_max = (LF*kVA*1000*PF)/((LF*kVA*1000*PF)+2*P_k)*100 #Max Efficiency 0.9 PF lagging(%) \n",
+ "#Case(g)\n",
+ "P_o = kVA*PF #Output power at 0.9 PF lagging(kW)\n",
+ "I_a = I_a_rated\n",
+ "P_d = P_o+(3*(I_a)**2*R_a/1000)+(V_f*I_f/1000) #Armature power developed at 0.9 PF lagging at full-load(kW)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rotational loss of the synchronous dynamo , P_r = %.f W' %P_r)\n",
+ "print('Case(b): Field copper loss , P_f = %.f W' %P_f)\n",
+ "print('Case(c): Fixed losses at rated synchronous speed , P_k = %.f W' %P_k)\n",
+ "print('Case(d): Electric armature copper loss at 1/4 rated load , P_cu = %.1f W' %P_cu_LF1)\n",
+ "print(' Electric armature copper loss at 1/2 rated load , P_cu = %.1f W' %P_cu_LF2)\n",
+ "print(' Electric armature copper loss at 3/4 rated load , P_cu = %.f W' %P_cu_LF3)\n",
+ "print(' Electric armature copper loss at rated load , P_cu = %.f W' %P_cu)\n",
+ "print('Case(e): Efficiency at 1/4 rated load , \u03b7 = %.1f percent' %n_1)\n",
+ "print(' Efficiency at 1/2 rated load , \u03b7 = %.1f percent' %n_2)\n",
+ "print(' Efficiency at 3/4 rated load , \u03b7 = %.1f percent' %n_3)\n",
+ "print(' Efficiency at rated load , \u03b7 = %.1f percent' %n_fl)\n",
+ "print('Case(f): Maximum efficiency at 0.9 PF lagging , \u03b7_max = %.1f percent' %n_max)\n",
+ "print('Case(g): Armature power developed at 0.9 PF lagging at full load , P_d = %.2f kW' %P_d)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rotational loss of the synchronous dynamo , P_r = 5914 W\n",
+ "Case(b): Field copper loss , P_f = 2250 W\n",
+ "Case(c): Fixed losses at rated synchronous speed , P_k = 8164 W\n",
+ "Case(d): Electric armature copper loss at 1/4 rated load , P_cu = 232.6 W\n",
+ " Electric armature copper loss at 1/2 rated load , P_cu = 930.2 W\n",
+ " Electric armature copper loss at 3/4 rated load , P_cu = 2093 W\n",
+ " Electric armature copper loss at rated load , P_cu = 3721 W\n",
+ "Case(e): Efficiency at 1/4 rated load , \u03b7 = 72.8 percent\n",
+ " Efficiency at 1/2 rated load , \u03b7 = 83.2 percent\n",
+ " Efficiency at 3/4 rated load , \u03b7 = 86.8 percent\n",
+ " Efficiency at rated load , \u03b7 = 88.3 percent\n",
+ "Case(f): Maximum efficiency at 0.9 PF lagging , \u03b7_max = 89.1 percent\n",
+ "Case(g): Armature power developed at 0.9 PF lagging at full load , P_d = 95.97 kW\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.13, Page number 430"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 1000.0 #Rating of the alternator(kVA)\n",
+ "V = 2300.0 #Rated voltage of the alternator(V)\n",
+ "hp = 100.0 #Power rating of the dc motor(hp)\n",
+ "V_motor = 240.0 #Rated voltage of the motor(V)\n",
+ "P_1 = 7.5 #Motor output(kW). TEST 1\n",
+ "P_2 = 16.0 #Motor output(kW). TEST 2\n",
+ "VfIf = 14.0 #Field losses(kW)\n",
+ "P_f = VfIf #Field losses(kW)\n",
+ "P_3 = 64.2 #Motor output(kW). TEST 3\n",
+ "I_sc = 251.0 #Short circuit current(A)\n",
+ "V_L = 1443.0 #Line voltage(V). TEST 4\n",
+ "R_a = 0.3 #Armature resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "P_r = P_2 #Rotational losses(kW). From TEST 2\n",
+ "#Case(b)\n",
+ "P_cu = P_3-P_1 #Full-load armature copper loss(kW)\n",
+ "#Case(c)\n",
+ "E_gL = V_L #Generated line voltage(V)\n",
+ "Z_s = (E_gL/3**0.5)/I_sc #Synchronous impedance of the armature(ohm)\n",
+ "#Case(d)\n",
+ "X_s = (Z_s**2-R_a**2)**0.5 #Synchronous reactance of the armature(ohm)\n",
+ "#Case(e)\n",
+ "PF = 0.8 #Lagging power factor\n",
+ "sin_theta = (1-PF**2)**0.5 #Sin\u03b8\n",
+ "V_p = V/3**0.5 #Phase voltage(V)\n",
+ "I_a = I_sc #Armature current(A)\n",
+ "E_gp = complex((V_p*PF+I_a*R_a),(V_p*sin_theta+I_a*X_s)) #Generated phase voltage(V)\n",
+ "V_nl = abs(E_gp) #No-load voltage(V)\n",
+ "V_fl = V_p #Full-load voltage(V)\n",
+ "VR = (V_nl-V_fl)/V_fl*100 #Alternator voltage regulation(%)\n",
+ "#Case(f)\n",
+ "LF = 1.0 #Load fraction\n",
+ "n_rated = (LF*kVA*PF)/((LF*kVA*PF)+(P_f+P_r)+P_cu)*100 #Efficiency at 0.8 lagging PF(%)\n",
+ "#Case(g)\n",
+ "P_k = (P_f+P_r) #Constant losses(kW)\n",
+ "L_F = (P_k/P_cu)**0.5 #Load fraction for max efficiency\n",
+ "n_max = (L_F*kVA*PF)/((L_F*kVA*PF)+2*P_k)*100 #Max Efficiency at 0.8 lagging PF(%)\n",
+ "#Case(h)\n",
+ "PF_h = 1.0 #Unity PF\n",
+ "P_o = kVA*PF_h #Output power(kW)\n",
+ "P_d = P_o+(3*(I_a)**2*R_a/1000)+(VfIf) #Armature power developed at rated-load unity PF(kW) \n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rotational losses , P_r = %.1f kW' %P_r)\n",
+ "print('Case(b): Full-load armature copper loss , P_cu = %.1f kW' %P_cu)\n",
+ "print('Case(c): Synchronous impedance of the armature , Z_s = %.2f \u03a9' %Z_s)\n",
+ "print('Case(d): Synchronous reactance of the armature , jX_s = %.2f \u03a9' %X_s)\n",
+ "print('Case(e): Alternator voltage regulation at 0.8 PF lagging , VR = %.2f percent' %VR)\n",
+ "print('Case(f): Alternator efficiency at 0.8 PF lagging at rated load , \u03b7_rated = %.1f percent' %n_rated)\n",
+ "print('Case(g): Maximum efficiency at 0.8 PF lagging , \u03b7_max = %.2f percent' %n_max)\n",
+ "print('Case(h): Power developed by the alternator armature at rated load, unity PF , P_d = %.f kW' %P_d)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rotational losses , P_r = 16.0 kW\n",
+ "Case(b): Full-load armature copper loss , P_cu = 56.7 kW\n",
+ "Case(c): Synchronous impedance of the armature , Z_s = 3.32 \u03a9\n",
+ "Case(d): Synchronous reactance of the armature , jX_s = 3.31 \u03a9\n",
+ "Case(e): Alternator voltage regulation at 0.8 PF lagging , VR = 49.47 percent\n",
+ "Case(f): Alternator efficiency at 0.8 PF lagging at rated load , \u03b7_rated = 90.2 percent\n",
+ "Case(g): Maximum efficiency at 0.8 PF lagging , \u03b7_max = 90.65 percent\n",
+ "Case(h): Power developed by the alternator armature at rated load, unity PF , P_d = 1071 kW\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.14, Page number 434"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 4.0 #Number of poles in Induction motor\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "V = 220.0 #Rated voltage of IM(V)\n",
+ "hp_IM = 5.0 #Power rating of IM(hp)\n",
+ "PF = 0.9 #Power factor\n",
+ "I_L = 16.0 #Line current(A)\n",
+ "S = 1750.0 #Speed of IM(rpm)\n",
+ "I_nl = 6.5 #No-load line current(A)\n",
+ "V_nl = 220.0 #No-load line voltage(V)\n",
+ "P_nl = 300.0 #No-load power reading(W)\n",
+ "I_br = 16.0 #Blocked rotor line current(A)\n",
+ "V_br = 50.0 #Blocked rotor voltage(V)\n",
+ "P_br = 800.0 #Blocked rotor power reading(W)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "P_cu = P_br #Full-load equivalent copper loss(W)\n",
+ "I_1 = I_br #Primary current(A)\n",
+ "R_e1 = P_cu/(3.0/2*I_1**2) #Equivalent total resistance of IM(ohm) \n",
+ "#Case(b)\n",
+ "P_in = P_nl #Input power to IM(W)\n",
+ "I1 = I_nl #Input current(A)\n",
+ "P_r = P_in-(3.0/2*I1**2*R_e1) #Rotational losses(W)\n",
+ "#Case(c)\n",
+ "LF1 = 1.0/4 #Load fraction\n",
+ "LF2 = 1.0/2 #Load fraction\n",
+ "LF3 = 3.0/4 #Load fraction\n",
+ "LF4 = 5.0/4 #Load fraction\n",
+ "P_cu_LF1 = LF1**2*P_cu #Equivalent copper loss at 1/4 rated-load(W)\n",
+ "P_cu_LF2 = LF2**2*P_cu #Equivalent copper loss at 1/2 rated-load(W)\n",
+ "P_cu_LF3 = LF3**2*P_cu #Equivalent copper loss at 3/4 rated-load(W)\n",
+ "P_cu_LF4 = LF4**2*P_cu #Equivalent copper loss at 5/4 rated-load(W)\n",
+ "#Case(d)\n",
+ "Full_load_input = 3**0.5*V*I_L*PF #Full-load input(W)\n",
+ "n_rated = (Full_load_input-(P_r+P_cu))/(Full_load_input)*100 #Efficiency at rated load(%)\n",
+ "n_LF1 = (Full_load_input*LF1-(P_r+P_cu_LF1))/(Full_load_input*LF1)*100 #Efficiency at 1/4 rated load(%)\n",
+ "n_LF2 = (Full_load_input*LF2-(P_r+P_cu_LF2))/(Full_load_input*LF2)*100 #Efficiency at 1/2 rated load(%)\n",
+ "n_LF3 = (Full_load_input*LF3-(P_r+P_cu_LF3))/(Full_load_input*LF3)*100 #Efficiency at 3/4 rated load(%)\n",
+ "n_LF4 = (Full_load_input*LF4-(P_r+P_cu_LF4))/(Full_load_input*LF4)*100 #Efficiency at 5/4 rated load(%)\n",
+ "#Case(e)\n",
+ "P_o = (Full_load_input*n_rated/100)/746 #Output hp at 1/4 rated load\n",
+ "P_o_LF1 = (Full_load_input*LF1*n_LF1/100)/746 #Output hp at 1/4 rated load\n",
+ "P_o_LF2 = (Full_load_input*LF2*n_LF2/100)/746 #Output hp at 1/2 rated load\n",
+ "P_o_LF3 = (Full_load_input*LF3*n_LF3/100)/746 #Output hp at 3/4 rated load\n",
+ "P_o_LF4 = (Full_load_input*LF4*n_LF4/100)/746 #Output hp at 5/4 rated load\n",
+ "#Case(f)\n",
+ "hp = P_o #Rated output(hp)\n",
+ "T_o = P_o*5252/S #Output torque at full-load(lb-ft)\n",
+ "T_o_Nm = T_o*1.356 #Output torque at full-load(N-m)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent total resistance of IM between lines , R_e1 = %.3f \u03a9' %R_e1)\n",
+ "print('Case(b): Rotational losses , P_r = %.f W' %P_r)\n",
+ "print('Case(c): Equivalent copper loss at full-load , P_cu = %d W' %P_cu)\n",
+ "print(' Equivalent copper loss at 1/4 rated load , P_cu = %d W' %P_cu_LF1)\n",
+ "print(' Equivalent copper loss at 1/2 rated load , P_cu = %d W' %P_cu_LF2)\n",
+ "print(' Equivalent copper loss at 3/4 rated load , P_cu = %d W' %P_cu_LF3)\n",
+ "print(' Equivalent copper loss at 5/4 rated load , P_cu = %d W' %P_cu_LF4)\n",
+ "print('Case(d): Efficiency at rated load , \u03b7 = %.1f percent' %n_rated)\n",
+ "print(' Efficiency at 1/4 rated load , \u03b7 = %.1f percent' %n_LF1)\n",
+ "print(' Efficiency at 1/2 rated load , \u03b7 = %.1f percent' %n_LF2)\n",
+ "print(' Efficiency at 3/4 rated load , \u03b7 = %.1f percent' %n_LF3)\n",
+ "print(' Efficiency at 5/4 rated load , \u03b7 = %.1f percent' %n_LF4)\n",
+ "print('Case(e): Output horsepower at rated load , P_o = %.2f hp' %P_o)\n",
+ "print(' Output horsepower at 1/4 rated load , P_o = %.3f hp' %P_o_LF1)\n",
+ "print(' Output horsepower at 1/2 rated load , P_o = %.3f hp' %P_o_LF2)\n",
+ "print(' Output horsepower at 3/4 rated load , P_o = %.2f hp' %P_o_LF3)\n",
+ "print(' Output horsepower at 5/4 rated load , P_o = %.2f hp' %P_o_LF4)\n",
+ "print('Case(f): Output torque at full-load , T_o = %.1f lb-ft' %T_o)\n",
+ "print(' Output torque at full-load , T_o = %.2f N-m' %T_o_Nm)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent total resistance of IM between lines , R_e1 = 2.083 \u03a9\n",
+ "Case(b): Rotational losses , P_r = 168 W\n",
+ "Case(c): Equivalent copper loss at full-load , P_cu = 800 W\n",
+ " Equivalent copper loss at 1/4 rated load , P_cu = 50 W\n",
+ " Equivalent copper loss at 1/2 rated load , P_cu = 200 W\n",
+ " Equivalent copper loss at 3/4 rated load , P_cu = 450 W\n",
+ " Equivalent copper loss at 5/4 rated load , P_cu = 1250 W\n",
+ "Case(d): Efficiency at rated load , \u03b7 = 82.4 percent\n",
+ " Efficiency at 1/4 rated load , \u03b7 = 84.1 percent\n",
+ " Efficiency at 1/2 rated load , \u03b7 = 86.6 percent\n",
+ " Efficiency at 3/4 rated load , \u03b7 = 85.0 percent\n",
+ " Efficiency at 5/4 rated load , \u03b7 = 79.3 percent\n",
+ "Case(e): Output horsepower at rated load , P_o = 6.06 hp\n",
+ " Output horsepower at 1/4 rated load , P_o = 1.547 hp\n",
+ " Output horsepower at 1/2 rated load , P_o = 3.184 hp\n",
+ " Output horsepower at 3/4 rated load , P_o = 4.69 hp\n",
+ " Output horsepower at 5/4 rated load , P_o = 7.29 hp\n",
+ "Case(f): Output torque at full-load , T_o = 18.2 lb-ft\n",
+ " Output torque at full-load , T_o = 24.65 N-m\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.15, Page number 438"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "pole = 4.0 #Number of poles in Induction motor\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "V = 220.0 #Rated voltage of IM(V)\n",
+ "hp_IM = 5.0 #Power rating of IM(hp)\n",
+ "PF = 0.9 #Power factor\n",
+ "I_L = 16.0 #Line current(A)\n",
+ "S_r = 1750.0 #Speed of IM(rpm)\n",
+ "I_nl = 6.5 #No-load line current(A)\n",
+ "V_nl = 220.0 #No-load line voltage(V)\n",
+ "P_nl = 300.0 #No-load power reading(W)\n",
+ "I_br = 16.0 #Blocked rotor line current(A)\n",
+ "V_br = 50.0 #Blocked rotor voltage(V)\n",
+ "P_br = 800.0 #Blocked rotor power reading(W)\n",
+ "R_dc = 1.0 #DC resistance between lines(ohm)\n",
+ "V = 220.0 #Voltage rating(V)\n",
+ "P_input = 5500.0 #Power drawn(W)\n",
+ "\n",
+ "#Calculation\n",
+ "R_e1 = 1.25*R_dc #Equivalent total resistance of IM(ohm)\n",
+ "P_in = P_nl #Input power to IM(W)\n",
+ "I1 = I_nl #Input current(A)\n",
+ "P_r = P_in-(3.0/2*(I1)**2*R_e1) #Rotational losses(W)\n",
+ "I_1 = I_L\n",
+ "SCL_fl = 3.0/2*(I_1)**2*R_e1 #Stator copper loss at full-load(W)\n",
+ "SPI = P_input #Stator power input(W)\n",
+ "RPI = SPI-SCL_fl #Rotor power input(W)\n",
+ "S = (120*f/pole) #Speed of synchronous magnetic field(rpm)\n",
+ "s = (S-S_r)/S #Slip\n",
+ "RPD_fl = RPI*(1-s) #Rotor power developed(W)\n",
+ "RPO_fl = RPD_fl-P_r #Rotor power output(W)\n",
+ "#Case(a)\n",
+ "P_o = RPO_fl\n",
+ "n_fl = (P_o/P_input)*100 #Full-load efficiency(%)\n",
+ "#Case(b)\n",
+ "hp = P_o/746 #Output horsepower at full load\n",
+ "T_o = hp*5252/S_r #Output torque(lb-ft)\n",
+ "T_o_Nm = T_o*1.356 #Output torque(N-m)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full-load efficiency , \u03b7_fl = %.1f percent' %n_fl)\n",
+ "print('Case(b): Output horsepower , hp = %.2f hp at full load' %hp)\n",
+ "print(' Output torque , T_o = %.1f lb-ft = %.1f N-m' %(T_o,T_o_Nm))\n",
+ "print('Case(c): Comparison of results')\n",
+ "print('\\t\\t\\t\\t Ex. 12-14 \\t\\t Ex. 12-15')\n",
+ "print('________________________________________________________________________')\n",
+ "print('\u03b7_fl(percent)\\t\\t\\t 82.4 \\t\\t\\t %.1f' %n_fl)\n",
+ "print('Rated output(hp)\\t\\t 6.06 \\t\\t\\t %.2f' %hp)\n",
+ "print('Rated output torque(lb-ft)\\t 18.2 \\t\\t\\t %.1f' %T_o)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full-load efficiency , \u03b7_fl = 84.7 percent\n",
+ "Case(b): Output horsepower , hp = 6.25 hp at full load\n",
+ " Output torque , T_o = 18.7 lb-ft = 25.4 N-m\n",
+ "Case(c): Comparison of results\n",
+ "\t\t\t\t Ex. 12-14 \t\t Ex. 12-15\n",
+ "________________________________________________________________________\n",
+ "\u03b7_fl(percent)\t\t\t 82.4 \t\t\t 84.7\n",
+ "Rated output(hp)\t\t 6.06 \t\t\t 6.25\n",
+ "Rated output torque(lb-ft)\t 18.2 \t\t\t 18.7\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.16, Page number 440"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "import numpy\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 6.0 #Number of poles in SCIM \n",
+ "S_r = 1176.0 #Rated rotor speed(rpm)\n",
+ "V = 220.0 #Voltage rating of SCIM(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "P_hp = 7.5 #Power rating of SCIM(hp)\n",
+ "R_ap = 0.3 #Armature resistance(ohm)\n",
+ "R_r = 0.144 #Rotor resistance(ohm)\n",
+ "jXm = 13.5 #Reactance(ohm)\n",
+ "jXs = 0.5 #Synchronous reactance(ohm)\n",
+ "jXlr = 0.2 #Locked rotor reactance(ohm)\n",
+ "P_r = 300.0 #Total rotational losses(W)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "S = 120*f/P #Speed of the rotating magnetic field(rpm)\n",
+ "s = (S-S_r)/S #Slip\n",
+ "R_r_s = R_r/s\n",
+ "V_p = V/3**0.5 #Voltage per phase(V)\n",
+ "I1_1 = complex(R_ap,jXm+jXs)\n",
+ "I1_2 = complex(0,-jXm)\n",
+ "I2_1 = complex(0,-jXm)\n",
+ "I2_2 = complex(R_r/s,jXm+jXlr)\n",
+ "V_1 = V_p\n",
+ "V_2 = 0\n",
+ "A = [[I1_1,I2_1],[I1_2,I2_2]] #Matrix containing above mesh eqns array\n",
+ "delta = numpy.linalg.det(A) #Determinant of A\n",
+ "#Case(b)\n",
+ "I_p = numpy.linalg.det([[V_1,I2_1],[V_2,I2_2]])/delta #Stator armature current(A)\n",
+ "I_1 = I_p\n",
+ "#Case(c)\n",
+ "I_r = numpy.linalg.det([[I1_1,V_1],[I1_2,V_2]])/delta #Rotor armature current(A)\n",
+ "I_2 = I_r\n",
+ "#Case(d)\n",
+ "theta_1 = cmath.phase(I_p)*180/math.pi #Motor PF angle(degrees)\n",
+ "cos_theta1 = math.cos(theta_1*math.pi/180) #Motor PF\n",
+ "#Case(e)\n",
+ "SPI = V_p*abs(I_p)*cos_theta1 #Stator power input(W)\n",
+ "#Case(f)\n",
+ "SCL = abs(I_p)**2*R_ap #Stator Copper Loss(W)\n",
+ "#Case(g)\n",
+ "RPI = SPI-SCL #Rotor power input(W) Method 1\n",
+ "RPI_2 = abs(I_r)**2*(R_r/s) #Rotor power input(W) Method 2\n",
+ "#Case(h)\n",
+ "RCL = s*RPI #Rotor copper losses(W)\n",
+ "#Case(i)\n",
+ "RPD_1 = RPI-RCL #Rotor power developed(W) Method 1\n",
+ "RPD_2 = RPI*(1-s) #Rotor power developed(W) Method 2\n",
+ "#Case(j)\n",
+ "RPO = 3*RPD_1-P_r #Total three-phase rotor power output(W)\n",
+ "#Case(k)\n",
+ "P_to = RPO #Total rotor power at the motor pulley(W)\n",
+ "T_o = 7.04*(P_to/S_r) #Total 3-phase torque(lb-ft)\n",
+ "#Case(l)\n",
+ "hp = P_to/746.0 #Output horsepower(hp)\n",
+ "#Case(m)\n",
+ "P_in = 3*SPI #Input power to stator(W)\n",
+ "n = P_to/P_in*100 #Motor efficiency at rated load(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Slip , s = %.2f' %s)\n",
+ "print(' R_r/s = %.1f \u03a9' %R_r_s)\n",
+ "print('Case(b): Stator armature current per phase , I_p = %.2f\u2220%.2f\u00b0 A' %(abs(I_p),cmath.phase(I_p)*180/math.pi))\n",
+ "print('Case(c): Rotor current per phase , I_r = %.1f\u2220%.2f\u00b0 A' %(abs(I_r),cmath.phase(I_r)*180/math.pi))\n",
+ "print('Case(d): Motor power factor , cos\u04e8 = %.3f' %cos_theta1)\n",
+ "print('Case(e): Stator power input per phase , SPI = %d W' %SPI)\n",
+ "print('Case(f): Stator copper loss per phase , SCL = %.1f W' %SCL)\n",
+ "print('Case(g): Rotor power input per phase , RPI = %.2f W (Method 1)' %RPI)\n",
+ "print(' Rotor power input per phase , RPI = %.2f W (Method 2)' %RPI_2)\n",
+ "print('Case(h): Rotor copper loss per phase , RCL = %.1f W' %RCL)\n",
+ "print('Case(i): Rotor power developed per phase , RPD = %.1f W (Method 1)' %RPD_1)\n",
+ "print(' Rotor power developed per phase , RPD = %.1f W (Method 2)' %RPD_2)\n",
+ "print('Case(j): Total three-phase rotor power output at shaft , RPO = %.1f W' %RPO)\n",
+ "print('Case(k): Total torque developed at output , T_o = %.2f lb-ft' %T_o)\n",
+ "print('Case(l): Horsepower output , hp = %.2f hp' %hp)\n",
+ "print('Case(m): Efficiency at rated load , \u03b7 = %.2f percent' %n)\n",
+ "print('Case(n): Power flow diagram is shown in textbook Fig. 12-12 page no 441')\n",
+ "print('\\nNOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Slip , s = 0.02\n",
+ " R_r/s = 7.2 \u03a9\n",
+ "Case(b): Stator armature current per phase , I_p = 18.69\u2220-31.75\u00b0 A\n",
+ "Case(c): Rotor current per phase , I_r = 16.3\u2220-4.03\u00b0 A\n",
+ "Case(d): Motor power factor , cos\u04e8 = 0.850\n",
+ "Case(e): Stator power input per phase , SPI = 2018 W\n",
+ "Case(f): Stator copper loss per phase , SCL = 104.8 W\n",
+ "Case(g): Rotor power input per phase , RPI = 1913.99 W (Method 1)\n",
+ " Rotor power input per phase , RPI = 1913.99 W (Method 2)\n",
+ "Case(h): Rotor copper loss per phase , RCL = 38.3 W\n",
+ "Case(i): Rotor power developed per phase , RPD = 1875.7 W (Method 1)\n",
+ " Rotor power developed per phase , RPD = 1875.7 W (Method 2)\n",
+ "Case(j): Total three-phase rotor power output at shaft , RPO = 5327.1 W\n",
+ "Case(k): Total torque developed at output , T_o = 31.89 lb-ft\n",
+ "Case(l): Horsepower output , hp = 7.14 hp\n",
+ "Case(m): Efficiency at rated load , \u03b7 = 87.96 percent\n",
+ "Case(n): Power flow diagram is shown in textbook Fig. 12-12 page no 441\n",
+ "\n",
+ "NOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.17, Page number 442"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 220.0 #Voltage rating of SCIM(V)\n",
+ "P_hp = 7.5 #Power rating of SCIM(hp)\n",
+ "kVA_up_limit = 7.99 #Upper limit of starting kVA/hp\n",
+ "kVA_low_limit = 7.1 #Lower limit of starting kVA/hp\n",
+ "\n",
+ "#Calculation\n",
+ "I_s_u = kVA_up_limit*P_hp*1000/(3**0.5*V) #Upper limit of starting current(A)\n",
+ "I_s_l = kVA_low_limit*P_hp*1000/(3**0.5*V) #Lower limit of starting current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Upper limit of the starting current , I_s = %.1f A' %I_s_u)\n",
+ "print('Case(b): Lower limit of the starting current , I_s = %.1f A' %I_s_l)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Upper limit of the starting current , I_s = 157.3 A\n",
+ "Case(b): Lower limit of the starting current , I_s = 139.7 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.18, Page number 442"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "import numpy\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 6.0 #Number of poles in SCIM \n",
+ "S_r = 1176.0 #Rated rotor speed(rpm)\n",
+ "V = 220.0 #Voltage rating of SCIM(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "P_hp = 7.5 #Power rating of SCIM(hp)\n",
+ "R_ap = 0.3 #Armature resistance(ohm)\n",
+ "R_r = 0.144 #Rotor resistance(ohm)\n",
+ "jXm = 13.5 #Reactance(ohm)\n",
+ "jXs = 0.5 #Synchronous reactance(ohm)\n",
+ "jXlr = 0.2 #Locked rotor reactance(ohm)\n",
+ "P_r = 300.0 #Total rotational losses(W)\n",
+ "s = 1.0 #Unity slip\n",
+ "\n",
+ "#Calculation\n",
+ "R_r_s = R_r/s\n",
+ "V_p = V/3**0.5 #Voltage per phase(V)\n",
+ "I1_1 = complex(R_ap,jXm+jXs)\n",
+ "I1_2 = complex(0,-jXm)\n",
+ "I2_1 = complex(0,-jXm)\n",
+ "I2_2 = complex(R_r/s,jXm+jXlr)\n",
+ "V_1 = V_p\n",
+ "V_2 = 0\n",
+ "A = [[I1_1,I2_1],[I1_2,I2_2]] #Matrix containing above mesh eqns array\n",
+ "delta = numpy.linalg.det(A) #Determinant of A\n",
+ "#Case(a)\n",
+ "I_s = numpy.linalg.det([[V_1,I2_1],[V_2,I2_2]])/delta #Stator armature current(A)\n",
+ "I_1 = I_s\n",
+ "#Case(b)\n",
+ "theta = cmath.phase(I_s)*180/math.pi #Phase angle of Stator armature current(degree)\n",
+ "cos_theta = math.cos(theta*math.pi/180) #PF of the motor at starting\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Starting stator current of the SCIM , I_s = I_1 = %.1f\u2220%.1f\u00b0 A' %(abs(I_s),theta))\n",
+ "print('Case(b): Power factor of the motor at starting , cos\u03b8 = %.3f ' %cos_theta)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Starting stator current of the SCIM , I_s = I_1 = 153.9\u2220-57.8\u00b0 A\n",
+ "Case(b): Power factor of the motor at starting , cos\u03b8 = 0.533 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.19, Page number 445"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 220.0 #Rated voltage of SCIM(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "P = 4.0 #Number of poles\n",
+ "PF = 0.85 #Power factor of capacitor-start IM\n",
+ "hp_IM = 5.0 #Power rating of IM(hp)\n",
+ "I_L = 28.0 #Rated line current(A)\n",
+ "S_r = 1620.0 #Rotor speed of IM(rpm)\n",
+ "I_nl = 6.4 #No-load line current(A)\n",
+ "V_nl = 220.0 #No-load line voltage(V)\n",
+ "P_nl = 239.0 #No-load power reading(W)\n",
+ "s_nl = 0.01 #No-load slip\n",
+ "I_br = 62.0 #Blocked rotor line current(A)\n",
+ "V_br = 64.0 #Blocked rotor voltage(V)\n",
+ "P_br = 1922.0 #Blocked rotor power reading(W)\n",
+ "s_br = 1.0 #Blocked rotor slip\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "R_els = P_br/I_br**2 #Equivalent total resistance of IM(ohm)\n",
+ "#Case(b)\n",
+ "P_in = P_nl #Input power to IM(W)\n",
+ "I_ls = I_nl #Input current(A)\n",
+ "P_ro = P_in-(I_ls**2*R_els) #Rotational losses(W)\n",
+ "#Case(c)\n",
+ "S = (120*f/P) #Speed of synchronous magnetic field(rpm)\n",
+ "S_fl = S_r #Full-load rotor speed of IM(rpm) \n",
+ "s_fl = (S-S_fl)/S #Full-load Slip \n",
+ "LF1 = 1.0/4 #Load fraction\n",
+ "LF2 = 1.0/2 #Load fraction\n",
+ "LF3 = 3.0/4 #Load fraction\n",
+ "LF4 = 5.0/4 #Load fraction\n",
+ "s_LF1 = s_fl*LF1 #slip at 1/4 rated load\n",
+ "s_LF2 = s_fl*LF2 #slip at 1/2 rated load\n",
+ "s_LF3 = s_fl*LF3 #slip at 3/4 rated load\n",
+ "s_LF4 = s_fl*LF4 #slip at 5/4 rated load\n",
+ "#Case(d)\n",
+ "s_o = s_nl #No-load slip\n",
+ "P_rs_fl = P_ro*(1-s_fl)/(1-s_o) #Rotational losses rated load(W)\n",
+ "P_rs_LF1 = P_ro*(1-s_LF1)/(1-s_o) #Rotational losses at 1/4 rated load(W)\n",
+ "P_rs_LF2 = P_ro*(1-s_LF2)/(1-s_o) #Rotational losses at 1/2 rated load(W)\n",
+ "P_rs_LF3 = P_ro*(1-s_LF3)/(1-s_o) #Rotational losses at 3/4 rated load(W)\n",
+ "P_rs_LF4 = P_ro*(1-s_LF4)/(1-s_o) #Rotational losses at 5/4 rated load(W)\n",
+ "#Case(e)\n",
+ "Ils = I_L #Line current(A)\n",
+ "P_cu_fl = Ils**2*R_els #Equivalent copper loss at full-load slip(W)\n",
+ "P_cu_LF1 = LF1**2*P_cu_fl #Equivalent copper loss at 1/4 rated load(W)\n",
+ "P_cu_LF2 = LF2**2*P_cu_fl #Equivalent copper loss at 1/2 rated load(W)\n",
+ "P_cu_LF3 = LF3**2*P_cu_fl #Equivalent copper loss at 3/4 rated load(W)\n",
+ "P_cu_LF4 = LF4**2*P_cu_fl #Equivalent copper loss at 5/4 rated load(W)\n",
+ "#Case(f)\n",
+ "Input = V*I_L*PF #Input to single phase capacitor start IM(W)\n",
+ "n_LF1 = (Input*LF1-(P_rs_LF1+P_cu_LF1))/(Input*LF1)*100 #Efficiency at 1/4 rated load(%)\n",
+ "n_LF2 = (Input*LF2-(P_rs_LF2+P_cu_LF2))/(Input*LF2)*100 #Efficiency at 1/2 rated load(%)\n",
+ "n_LF3 = (Input*LF3-(P_rs_LF3+P_cu_LF3))/(Input*LF3)*100 #Efficiency at 3/4 rated load(%)\n",
+ "n_LF4 = (Input*LF4-(P_rs_LF4+P_cu_LF4))/(Input*LF4)*100 #Efficiency at 5/4 rated load(%)\n",
+ "n_fl = (Input-(P_rs_fl+P_cu_fl))/(Input)*100 #Efficiency at full load(%)\n",
+ "#Case(g)\n",
+ "P_o_LF1 = (Input*LF1*n_LF1/100)/746 #Output hp at 1/4 rated load\n",
+ "P_o_LF2 = (Input*LF2*n_LF2/100)/746 #Output hp at 1/2 rated load\n",
+ "P_o_LF3 = (Input*LF3*n_LF3/100)/746 #Output hp at 3/4 rated load\n",
+ "P_o_LF4 = (Input*LF4*n_LF4/100)/746 #Output hp at 5/4 rated load\n",
+ "P_o = (Input*n_fl/100)/746 #Output hp at rated load\n",
+ "#Case(h)\n",
+ "hp = P_o #Rated output horsepower\n",
+ "S_fl = S_r #Full-load rotor speed(rpm)\n",
+ "T_o = P_o*5252/S_fl #Output torque at full-load(lb-ft)\n",
+ "T_o_ST = T_o*1.356 #Output torque at full-load(N-m)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent total resistance of motor between lines , R_els = %.1f \u03a9' %R_els)\n",
+ "print('Case(b): Rotational losses at no load , P_ro = %.1f W' %P_ro)\n",
+ "print('Case(c): Slip at rated load , s_fl = %.1f ' %s_fl)\n",
+ "print(' Slip at 1/4 rated load , s = %.3f ' %s_LF1)\n",
+ "print(' Slip at 1/2 rated load , s = %.2f ' %s_LF2)\n",
+ "print(' Slip at 3/4 rated load , s = %.3f ' %s_LF3)\n",
+ "print(' Slip at 5/4 rated load , s = %.3f ' %s_LF4)\n",
+ "print('Case(d): Rotational loss at rated load , P_r = %.1f W' %P_rs_fl)\n",
+ "print(' Rotational loss at 1/4 load , P_r = %.1f W' %P_rs_LF1)\n",
+ "print(' Rotational loss at 1/2 load , P_r = %.2f W' %P_rs_LF2)\n",
+ "print(' Rotational loss at 3/4 load , P_r = %.1f W' %P_rs_LF3)\n",
+ "print(' Rotational loss at 5/4 load , P_r = %.1f W' %P_rs_LF4)\n",
+ "print('Case(e): Equivalent copper loss at rated load , P_cu = %.f W' %P_cu_fl)\n",
+ "print(' Equivalent copper loss at 1/4 load , P_cu = %.1f W' %P_cu_LF1)\n",
+ "print(' Equivalent copper loss at 1/2 load , P_cu = %.f W' %P_cu_LF2)\n",
+ "print(' Equivalent copper loss at 3/4 load , P_cu = %.1f W' %P_cu_LF3)\n",
+ "print(' Equivalent copper loss at 5/4 load , P_cu = %.1f W' %P_cu_LF4)\n",
+ "print('Case(f): Efficiency at rated load , \u03b7 = %.1f W' %n_fl)\n",
+ "print(' Efficiency at 1/4 rated load , \u03b7 = %.1f W' %n_LF1)\n",
+ "print(' Efficiency at 1/2 rated load , \u03b7 = %.1f W' %n_LF2)\n",
+ "print(' Efficiency at 3/4 rated load , \u03b7 = %.1f W' %n_LF3)\n",
+ "print(' Efficiency at 5/4 rated load , \u03b7 = %.1f W' %n_LF4)\n",
+ "print('Case(g): Output horsepower at rated load , P_o = %.2f hp' %P_o)\n",
+ "print(' Output horsepower at 1/4 rated load , P_o = %.2f hp' %P_o_LF1)\n",
+ "print(' Output horsepower at 1/2 rated load , P_o = %.2f hp' %P_o_LF2)\n",
+ "print(' Output horsepower at 3/4 rated load , P_o = %.2f hp' %P_o_LF3)\n",
+ "print(' Output horsepower at 5/4 rated load , P_o = %.2f hp' %P_o_LF4)\n",
+ "print('Case(h): Output torque at full load , T_o = %.1f lb-ft' %T_o)\n",
+ "print(' Output torque at full load , T_oST = %.1f N-m' %T_o_ST)\n",
+ "print('\\nNOTE: ERROR: Calculation error for efficiency at 3/4 load in textbook')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent total resistance of motor between lines , R_els = 0.5 \u03a9\n",
+ "Case(b): Rotational losses at no load , P_ro = 218.5 W\n",
+ "Case(c): Slip at rated load , s_fl = 0.1 \n",
+ " Slip at 1/4 rated load , s = 0.025 \n",
+ " Slip at 1/2 rated load , s = 0.05 \n",
+ " Slip at 3/4 rated load , s = 0.075 \n",
+ " Slip at 5/4 rated load , s = 0.125 \n",
+ "Case(d): Rotational loss at rated load , P_r = 198.7 W\n",
+ " Rotational loss at 1/4 load , P_r = 215.2 W\n",
+ " Rotational loss at 1/2 load , P_r = 209.69 W\n",
+ " Rotational loss at 3/4 load , P_r = 204.2 W\n",
+ " Rotational loss at 5/4 load , P_r = 193.1 W\n",
+ "Case(e): Equivalent copper loss at rated load , P_cu = 392 W\n",
+ " Equivalent copper loss at 1/4 load , P_cu = 24.5 W\n",
+ " Equivalent copper loss at 1/2 load , P_cu = 98 W\n",
+ " Equivalent copper loss at 3/4 load , P_cu = 220.5 W\n",
+ " Equivalent copper loss at 5/4 load , P_cu = 612.5 W\n",
+ "Case(f): Efficiency at rated load , \u03b7 = 88.7 W\n",
+ " Efficiency at 1/4 rated load , \u03b7 = 81.7 W\n",
+ " Efficiency at 1/2 rated load , \u03b7 = 88.2 W\n",
+ " Efficiency at 3/4 rated load , \u03b7 = 89.2 W\n",
+ " Efficiency at 5/4 rated load , \u03b7 = 87.7 W\n",
+ "Case(g): Output horsepower at rated load , P_o = 6.23 hp\n",
+ " Output horsepower at 1/4 rated load , P_o = 1.43 hp\n",
+ " Output horsepower at 1/2 rated load , P_o = 3.10 hp\n",
+ " Output horsepower at 3/4 rated load , P_o = 4.69 hp\n",
+ " Output horsepower at 5/4 rated load , P_o = 7.69 hp\n",
+ "Case(h): Output torque at full load , T_o = 20.2 lb-ft\n",
+ " Output torque at full load , T_oST = 27.4 N-m\n",
+ "\n",
+ "NOTE: ERROR: Calculation error for efficiency at 3/4 load in textbook\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_13.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_13.ipynb new file mode 100755 index 00000000..094f4068 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_13.ipynb @@ -0,0 +1,563 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 13: RATINGS, SELECTION, AND MAINTENANCE OF ELECTRIC MACHINERY"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.1, Page number 460"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "T = 125.0 #Recorded temperature by the embedded detectors(\u00b0C)\n",
+ "life_orig = 10.0 #Standard life of the motor(years)\n",
+ "\n",
+ "#Calculation\n",
+ "delta_T = T-105 #Positive temp diff b/w the given max hottest spot temp of its insulation and ambient temp recorded\n",
+ "R = 2**(delta_T/10.0) #Life reduction factor\n",
+ "Life_calc = life_orig/R #Reduced life expectancy of the motor(years)\n",
+ "\n",
+ "#Result\n",
+ "print('Life reduction factor , R = %.f ' %R)\n",
+ "print('Reduced life expectancy of the motor , Life_calc = %.1f years' %Life_calc)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Life reduction factor , R = 4 \n",
+ "Reduced life expectancy of the motor , Life_calc = 2.5 years\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.2, Page number 460"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "T = 75.0 #Recorded temperature by the embedded detectors(\u00b0C)\n",
+ "life_orig = 10.0 #Standard life of the motor(years)\n",
+ "\n",
+ "#Calculation\n",
+ "delta_T = 105-T #Positive temp diff b/w the given max hottest spot temp of its insulation and ambient temp recorded\n",
+ "E = 2**(delta_T/10.0) #Life extension factor\n",
+ "Life_calc = life_orig*E #Increased life expectancy of the motor(years)\n",
+ "\n",
+ "#Result\n",
+ "print('Life extension factor , E = %.f ' %E)\n",
+ "print('Increased life expectancy of the motor , Life_calc = %.f years' %Life_calc)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Life extension factor , E = 8 \n",
+ "Increased life expectancy of the motor , Life_calc = 80 years\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.3, Page number 461"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "T_A = 105.0 #Recorded temperature by the embedded detectors at hottest spot limiting temp by class A(\u00b0C)\n",
+ "T_B = 130.0 #Recorded temperature by the embedded detectors at hottest spot limiting temp by class B(\u00b0C)\n",
+ "life_orig = 5.0 #Standard life of the motor(years)\n",
+ "\n",
+ "#Calculation\n",
+ "delta_T = T_B-T_A #Positive temp diff b/w the given max hottest spot temp of its insulation and ambient temp recorded\n",
+ "E = 2**(delta_T/10.0) #Life extension factor\n",
+ "Life_new = life_orig*E #Increased life expectancy of the motor(years)\n",
+ "\n",
+ "#Result\n",
+ "print('New life if wound with class B insulation , Life_new = %.1f years' %Life_new)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "New life if wound with class B insulation , Life_new = 28.3 years\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.4, Page number 463"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P_o = 25.0 #Rated power of SCIM(hp)\n",
+ "T_ambient = 40.0 #Standard ambient temperature recorded by the embedded hot-spot detectors(\u00b0C)\n",
+ "T_hottest = 115.0 #Hottest-spot winding temperature recorded by the embedded hot-spot detectors(\u00b0C)\n",
+ "\n",
+ "#Calculation\n",
+ "delta_Tf = 90.0 #Allowable temperature rise for the insulation type used(\u00b0C)\n",
+ "T_rise = T_hottest-T_ambient #Actual temperature rise of the SCIM(\u00b0C)\n",
+ "P_f = P_o*(delta_Tf/T_rise) #Approximate power the motor can deliver at temperature rise(hp)\n",
+ "power = 30.0 #Power rating that may be stamped on the name plate(hp)\n",
+ "delta_Tf_e = 90.0 #Temperature rise that must be stamped on the name plate(\u00b0C)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Allowable temperature rise for the insulation type used = %.f\u00b0C' %delta_Tf)\n",
+ "print('Case(b): Actual temperature rise of the SCIM = %.f\u00b0C' %T_rise)\n",
+ "print('Case(c): Approximate power the motor can deliver at the temperature rise , P_f = %.f hp' %P_f)\n",
+ "print('Case(d): Power rating that may be stamped on the name plate = %.f hp' %power)\n",
+ "print('Case(e): Temperature rise that must be stamped on the name plate = %.f\u00b0C' %delta_Tf_e)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Allowable temperature rise for the insulation type used = 90\u00b0C\n",
+ "Case(b): Actual temperature rise of the SCIM = 75\u00b0C\n",
+ "Case(c): Approximate power the motor can deliver at the temperature rise , P_f = 30 hp\n",
+ "Case(d): Power rating that may be stamped on the name plate = 30 hp\n",
+ "Case(e): Temperature rise that must be stamped on the name plate = 90\u00b0C\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.5, Page number 464"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P_o = 50.0 #Power rating of the WRIM(hp)\n",
+ "T_hottest = 160.0 #Hottest-spot winding temperature recorded by the embedded hot-spot detectors(\u00b0C)\n",
+ "T_ambient = 40.0 #Standard ambient temperature recorded by the embedded hot-spot detectors(\u00b0C)\n",
+ "P_f_a = 40.0 #Power rating of load(hp)\n",
+ "P_f_b = 55.0 #Power rating of load(hp)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "delta_T_o = T_hottest-T_ambient #Temperature rise for the insulation type used(\u00b0C)\n",
+ "delta_T_f_a = (P_f_a/P_o)*delta_T_o #Final temperature rise(\u00b0C)\n",
+ "T_f_a = delta_T_f_a+T_ambient #Approximate final hot-spot temperature(\u00b0C)\n",
+ "#Case(b)\n",
+ "delta_T_f_b = (P_f_b/P_o)*delta_T_o #Final temperature rise(\u00b0C)\n",
+ "T_f_b = delta_T_f_b+T_ambient #Approximate final hot-spot temperature(\u00b0C)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Approximate final hot-spot temperature at a continuous output load of 40 hp , T_f = %.f\u00b0C ' %T_f_a)\n",
+ "print('Case(b): Approximate final hot-spot temperature at a continuous output load of 55 hp , T_f = %.f\u00b0C ' %T_f_b)\n",
+ "print(' Yes, Motor life is reduced at 110 percent motor load because allowable maximum hot-spot motor temperature is 155\u00b0C')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Approximate final hot-spot temperature at a continuous output load of 40 hp , T_f = 136\u00b0C \n",
+ "Case(b): Approximate final hot-spot temperature at a continuous output load of 55 hp , T_f = 172\u00b0C \n",
+ " Yes, Motor life is reduced at 110 percent motor load because allowable maximum hot-spot motor temperature is 155\u00b0C\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.6, Page number 464"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P_o = 55.0 #Power rating of the WRIM(hp)\n",
+ "T_ambient = 40.0 #Standard ambient temperature recorded by the embedded hot-spot detectors(\u00b0C)\n",
+ "life_orig = 10.0 #Standard life of the motor(years)\n",
+ "T_f = 172.0 #Approximate final hot-spot temperature(\u00b0C)\n",
+ "\n",
+ "#Calculation\n",
+ "delta_T = T_f-155.0 #Positive temp diff b/w the given max hottest spot temp of its insulation and ambient temp recorded\n",
+ "R = 2**(delta_T/10.0) #Life reduction factor\n",
+ "Life_calc = life_orig/R #Reduced life expectancy of the motor(years)\n",
+ "\n",
+ "#Result\n",
+ "print('Reduced life expectancy of the motor , Life_calc = %.2f years' %Life_calc)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Reduced life expectancy of the motor , Life_calc = 3.08 years\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.7, Page number 466"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P_o = 200.0 #Power rating of the test motor(hp)\n",
+ "P1 = 200.0 #Operating power of test motor at t1 duration(hp)\n",
+ "t1 = 5.0 #Time duration for which test motor is operated(min) \n",
+ "P2 = 20.0 #Operating power of test motor at t2 duration(hp)\n",
+ "t2 = 5.0 #Time duration for which test motor is operated(min)\n",
+ "P3 = 0.0 #Operating power of test motor at t3 duration at rest(hp)\n",
+ "t3 = 10.0 #Time duration for which test motor is operated(min)\n",
+ "P4 = 100.0 #Operating power of test motor at t4 duration(hp)\n",
+ "t4 = 10.0 #Time duration for which test motor is operated(min) \n",
+ "\n",
+ "#Calculation\n",
+ "rms_hp = ((P1**2*t1+P2**2*t2+P3**2*t3+P4**2*t4)/(t1+t2+t3+t4/3))**0.5 #HP required for intermittent varying load\n",
+ "\n",
+ "#Result\n",
+ "print('Horsepower required for such an intermittent varying load , rms hp = %.f hp' %rms_hp)\n",
+ "print('125 hp motor would be selected because that is the nearest larger commercial standard rating')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Horsepower required for such an intermittent varying load , rms hp = 114 hp\n",
+ "125 hp motor would be selected because that is the nearest larger commercial standard rating\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.8, Page number 472"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 120.0 #Rated output voltage of separately excited dc generator(V)\n",
+ "I = 100.0 #Rated output current of separately excited dc generator(A)\n",
+ "R = 0.1 #Armature resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "V_b = V #Base voltage(V)\n",
+ "I_b = I #Base current(A)\n",
+ "R_b = V_b/I_b #Base resistance(ohm)\n",
+ "R_pu = R/R_b #Per-unit value of armature resistance\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Base voltage , V_b = %.f V' %V_b)\n",
+ "print('Case(b): Base current , I_b = %.f A' %I_b)\n",
+ "print('Case(b): Base resistance , R_b = %.1f \u03a9' %R_b)\n",
+ "print('Case(d): Per-unit value of armature resistance , R_p.u = %.3f p.u' %R_pu)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Base voltage , V_b = 120 V\n",
+ "Case(b): Base current , I_b = 100 A\n",
+ "Case(b): Base resistance , R_b = 1.2 \u03a9\n",
+ "Case(d): Per-unit value of armature resistance , R_p.u = 0.083 p.u\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.9, Page number 473"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "V = 500.0 #Rated voltage of the alternator(V)\n",
+ "P = 20.0 #Rated power of the alternator(kVA)\n",
+ "I = 40.0 #Rated current of the alternator(A)\n",
+ "R = 2.0 #Armature resistance(ohm)\n",
+ "X = 15.0 #Armature reactance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "V_b = V #Base voltage(V)\n",
+ "I_b = I #Base current(A)\n",
+ "R_pu = R*I_b/V_b #Per-unit value of armature resistance\n",
+ "jX_pu = X*I_b/V_b #Per-unit value of armature reactance\n",
+ "Z_pu1 = complex(R_pu,jX_pu) #Per-unit value of armature impedance\n",
+ "Z_pu2 = complex(R,X)*(I/V) #Per-unit value of armature impedance\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Per unit value of armature resistance , R_p.u = %.2f p.u' %R_pu)\n",
+ "print('Case(b): Per unit value of armature reactance , jX_p.u = j%.1f p.u' %jX_pu)\n",
+ "print('Case(c): Per-unit value of armature impedance , Z_p.u = %.3f\u2220%.1f\u00b0 p.u (Method 1)' %(abs(Z_pu1),cmath.phase(Z_pu1)*180/math.pi))\n",
+ "print(' Per-unit value of armature impedance , Z_p.u = %.3f\u2220%.1f\u00b0 p.u (Method 2)' %(abs(Z_pu2),cmath.phase(Z_pu2)*180/math.pi))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Per unit value of armature resistance , R_p.u = 0.16 p.u\n",
+ "Case(b): Per unit value of armature reactance , jX_p.u = j1.2 p.u\n",
+ "Case(c): Per-unit value of armature impedance , Z_p.u = 1.211\u222082.4\u00b0 p.u (Method 1)\n",
+ " Per-unit value of armature impedance , Z_p.u = 1.211\u222082.4\u00b0 p.u (Method 2)\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.10, Page number 473"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_orig = 500.0 #Rated voltage of the alternator(V)\n",
+ "kVA_orig = 20.0 #Rated power of the alternator(kVA)\n",
+ "I = 40.0 #Rated current of the alternator(A)\n",
+ "R = 2.0 #Armature resistance(ohm)\n",
+ "X = 15.0 #Armature reactance(ohm)\n",
+ "V_new = 5000.0 #New voltage of the alternator(V)\n",
+ "kVA_new = 100.0 #New power of the alternator(kVA)\n",
+ "Z_pu_orig = 1.211 #Original per-unit value of armature impedance\n",
+ "\n",
+ "#Calculation\n",
+ "Z_pu_new = Z_pu_orig*(kVA_new/kVA_orig)*(V_orig/V_new)**2 #New per-unit impedance\n",
+ "\n",
+ "#Result\n",
+ "print('New per-unit impedance , Z_pu(new) = %.5f p.u' %Z_pu_new)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "New per-unit impedance , Z_pu(new) = 0.06055 p.u\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.11, Page number 474"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 2300.0 #Line voltage of 3-phase distribution system(V)\n",
+ "V_p = 1328.0 #Phase voltage of 3-phase distribution system(V)\n",
+ "V_b = 69000.0 #Common base line voltage(V)\n",
+ "V_pb = 39840.0 #Common base phase voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "V_pu_line = V/V_b #Distribution system p.u line voltage\n",
+ "V_pu_phase = V_p/V_pb #Distribution system p.u phase voltage\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Distribution system p.u line voltage , V_pu = %.2f p.u' %V_pu_line)\n",
+ "print('Case(b): Distribution system p.u phase voltage , V_pu = %.2f p.u' %V_pu_phase)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Distribution system p.u line voltage , V_pu = 0.03 p.u\n",
+ "Case(b): Distribution system p.u phase voltage , V_pu = 0.03 p.u\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.12, Page number 474"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "VA_b = 50.0 #Base power rating of the 3-phase Y-connected alternator(MVA)\n",
+ "V_b = 25.0 #Base voltage of the 3-phase Y-connected alternator(kV)\n",
+ "X_pu = 1.3 #Per unit value of synchronous reactance\n",
+ "R_pu = 0.05 #Per unit value of resistance\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "Z_b1 = V_b**2/VA_b #Base impedance(ohm)\n",
+ "S_b = VA_b #Base power rating of the 3-phase Y-connected alternator(MVA)\n",
+ "I_b = S_b/V_b #Base current(kA)\n",
+ "Z_b2 = V_b/I_b #Base impedance(ohm)\n",
+ "#Case(b)\n",
+ "Z_b = Z_b1 #Base impedance(ohm)\n",
+ "X_s = X_pu*Z_b #Actual value of synchronous reactance per phase(ohm)\n",
+ "#Case(c)\n",
+ "R_a = R_pu*Z_b #Actual value of armature stator resistance per phase(ohm)\n",
+ "#Case(d)\n",
+ "Z_s1 = complex(R_a,X_s) #Synchronous impedance per phase(ohm)\n",
+ "Z_pu = complex(R_pu,X_pu) #Per unit value of impedance\n",
+ "Z_s2 = Z_pu*Z_b #Synchronous impedance per phase(ohm)\n",
+ "#Case(d)\n",
+ "S = S_b #Base power rating of the 3-phase Y-connected alternator(MVA)\n",
+ "P = S*R_pu #Full-load copper losses for all three phases(MW)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Base impedance , Z_b = %.1f \u03a9' %Z_b1)\n",
+ "print(' Base impedance , Z_b = %.1f \u03a9' %Z_b2)\n",
+ "print('Case(b): Actual value of synchronous reactance per phase , X_s = j%.2f \u03a9' %X_s)\n",
+ "print('Case(c): Actual value of armature stator resistance per phase , R_a = %.3f \u03a9' %R_a)\n",
+ "print('Case(d): Synchronous impedance per phase , Z_s = %.2f\u2220%.1f\u00b0 \u03a9 (Method 1)' %(abs(Z_s1),cmath.phase(Z_s1)*180/math.pi))\n",
+ "print(' Synchronous impedance per phase , Z_s = %.2f\u2220%.1f\u00b0 \u03a9 (Method 2)' %(abs(Z_s2),cmath.phase(Z_s2)*180/math.pi))\n",
+ "print('Case(e): Full-load copper losses for all three phases , P = %.1f MW' %P)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Base impedance , Z_b = 12.5 \u03a9\n",
+ " Base impedance , Z_b = 12.5 \u03a9\n",
+ "Case(b): Actual value of synchronous reactance per phase , X_s = j16.25 \u03a9\n",
+ "Case(c): Actual value of armature stator resistance per phase , R_a = 0.625 \u03a9\n",
+ "Case(d): Synchronous impedance per phase , Z_s = 16.26\u222087.8\u00b0 \u03a9 (Method 1)\n",
+ " Synchronous impedance per phase , Z_s = 16.26\u222087.8\u00b0 \u03a9 (Method 2)\n",
+ "Case(e): Full-load copper losses for all three phases , P = 2.5 MW\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_14.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_14.ipynb new file mode 100755 index 00000000..2f2f7423 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_14.ipynb @@ -0,0 +1,2601 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 14: TRANSFORMERS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.1, Page number 487"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "N_1 = 500.0 #Number of turns in the hv side i.e primary\n",
+ "N_2 = 100.0 #Number of turns in the lv side i.e secondary\n",
+ "I_2 = 12.0 #Load current i.e secondary(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#For step-down transformer\n",
+ "alpha = N_1/N_2 #Transformation ratio\n",
+ "I_1 = I_2/alpha #Load component of primary current(A)\n",
+ "#For step-up transformer\n",
+ "N1 = 100.0 #Number of turns in the lv side i.e primary\n",
+ "N2 = 500.0 #Number of turns in the hv side i.e secondary\n",
+ "alpha_c = N1/N2 #Transformation ratio\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Transformation ratio , \u03b1 = %.f ' %alpha)\n",
+ "print('Case(b): Load component of primary current , I_1 = %.1f A' %I_1)\n",
+ "print('Case(c): Transformation ratio if transformer is used as step-up , \u03b1 = %.1f ' %alpha_c)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Transformation ratio , \u03b1 = 5 \n",
+ "Case(b): Load component of primary current , I_1 = 2.4 A\n",
+ "Case(c): Transformation ratio if transformer is used as step-up , \u03b1 = 0.2 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.2, Page number 488"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_h = 2300.0 #Primary voltage i.e hv(V)\n",
+ "V_l = 115.0 #Secondary voltage i.e lv(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "S = 4.6 #Rating of the step-down transformer(kVA)\n",
+ "V_per_turn = 2.5 #Induced EMF per turn(V/turn)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "N_h = V_h/V_per_turn #Number of high-side turns\n",
+ "N_l = V_l/V_per_turn #Number of low-side turns\n",
+ "N_1 = N_h\n",
+ "N_2 = N_l\n",
+ "#Case(b)\n",
+ "V_1 = V_h\n",
+ "V_2 = V_l\n",
+ "S_1 = S\n",
+ "S_2 = S\n",
+ "I_1 = S_1*1000/V_1 #Rated primary current(A)\n",
+ "I_2 = S_2*1000/V_2 #Rated secondary current(A)\n",
+ "I_h = I_1\n",
+ "I_l = I_2\n",
+ "#Case(c)\n",
+ "alpha_stepdown_c = N_1/N_2 #Step-down transformation ratio\n",
+ "alpha_stepup_c = N_l/N_h #Step-up transformation ratio\n",
+ "#Case(d)\n",
+ "alpha_stepdown_d = I_2/I_1 #Step-down transformation ratio\n",
+ "alpha_stepup_d = I_h/I_l #Step-up transformation ratio\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Number of high-side turns , N_h = %.f t = N_1 ' %N_h)\n",
+ "print(' Number of low-side turns , N_l = %.f t = N_2 ' %N_l)\n",
+ "print('Case(b): Rated primary current , I_h = I_1 = %.f A' %I_h)\n",
+ "print(' Rated secondary current , I_l = I_2 = %.f A' %I_l)\n",
+ "print('Case(c): Step-down transformation ratio , \u03b1 = %.f ' %alpha_stepdown_c);\n",
+ "print(' Step-up transformation ratio , \u03b1 = %.2f ' %alpha_stepup_c);\n",
+ "print('Case(d): Step-down transformation ratio , \u03b1 = %.f ' %alpha_stepdown_d);\n",
+ "print(' Step-up transformation ratio , \u03b1 = %.2f ' %alpha_stepup_d);"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Number of high-side turns , N_h = 920 t = N_1 \n",
+ " Number of low-side turns , N_l = 46 t = N_2 \n",
+ "Case(b): Rated primary current , I_h = I_1 = 2 A\n",
+ " Rated secondary current , I_l = I_2 = 40 A\n",
+ "Case(c): Step-down transformation ratio , \u03b1 = 20 \n",
+ " Step-up transformation ratio , \u03b1 = 0.05 \n",
+ "Case(d): Step-down transformation ratio , \u03b1 = 20 \n",
+ " Step-up transformation ratio , \u03b1 = 0.05 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.3, Page number 489"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "N_1 = 500.0 #Number of primary turns\n",
+ "N_2 = 25.0 #Number of secondary turns\n",
+ "Z_L = 8.0 #Impedance(ohm)\n",
+ "V_1 = 10.0 #Output voltage of the amplifier(V)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = N_1/N_2 #Step-down transformation ratio\n",
+ "Z_1 = alpha**2*Z_L #Impedance reflected to the transformer primary at the output of the amplifier(ohm)\n",
+ "I_1 = V_1/Z_1*1000 #Matching transformer primary current(mA)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Impedance reflected to the transformer primary at the output of the amplifier , Z_1 = %.f \u03a9' %Z_1)\n",
+ "print('Case(b): Matching transformer primary current , I_1 = %.3f mA' %I_1)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Impedance reflected to the transformer primary at the output of the amplifier , Z_1 = 3200 \u03a9\n",
+ "Case(b): Matching transformer primary current , I_1 = 3.125 mA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.4, Page number 490"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "N_1 = 600.0 #Number of primary turns \n",
+ "N_2 = 150.0 #Some number of secondary turns \n",
+ "N_3 = 300.0 #Some number of secondary turns \n",
+ "Z_2 = 30.0 #Resistive load across N_2(ohm)\n",
+ "Z_3 = 15.0 #Resistive load across N_3(ohm)\n",
+ "V_p = 16.0 #Primary applied voltage(V)\n",
+ "cos_theta = 1.0 #Unity PF\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "Z_2_prime = Z_2*(N_1/N_2)**2 #Impedance reflected to the primary by load Z_2(ohm)\n",
+ "#Case(b)\n",
+ "Z_3_prime = Z_3*(N_1/N_3)**2 #Impedance reflected to the primary by load Z_3(ohm)\n",
+ "#Case(c)\n",
+ "Z_1 = (Z_2_prime*Z_3_prime)/(Z_2_prime+Z_3_prime) #Total impedance reflected to primary(ohm)\n",
+ "#Case(d)\n",
+ "I_1 = V_p/Z_1 #Total current drawn from the supply(A)\n",
+ "#Case(e)\n",
+ "P_t = V_p*I_1*cos_theta #Total power drawn from the supply at unity PF(W)\n",
+ "#Case(f)\n",
+ "R_2 = Z_2\n",
+ "V_2 = V_p*(N_2/N_1) #Voltage across load Z_2(V)\n",
+ "P_2 = V_2**2/R_2 #Power dissipated in load Z_2(W)\n",
+ "#Case(g)\n",
+ "R_3 = Z_3\n",
+ "V_3 = V_p*(N_3/N_1) #Voltage across Z_3 in volt\n",
+ "P_3 = V_3**2 / R_3 #Power dissipated in load Z_3(W)\n",
+ "#Case(h)\n",
+ "P_total = P_2+P_3 #Total power dissipated in both loads(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Impedance reflected to the primary by load Z_2 = %.f \u03a9' %Z_2_prime)\n",
+ "print('Case(b): Impedance reflected to the primary by load Z_3 = %.f \u03a9' %Z_3_prime)\n",
+ "print('Case(c): Total impedance reflected to the primary , Z_1 = %.1f \u03a9' %Z_1)\n",
+ "print('Case(d): Total current drawn from the supply , I_1 = %.1f A' %I_1)\n",
+ "print('Case(e): Total power drawn from the supply at unity power factor , P_t = %.1f W' %P_t)\n",
+ "print('Case(f): Voltage across load Z_2 , V_2 = %.f V' %V_2)\n",
+ "print(' Power dissipated in load Z_2 , P_2 = %.2f W' %P_2)\n",
+ "print('Case(g): Voltage across load Z_3 , V_3 = %.f V' %V_3)\n",
+ "print(' Power dissipated in load Z_3 , P_3 = %.2f W' %P_3)\n",
+ "print('Case(h): Total power dissipated in both loads , P_t = %.1f W ' %P_total)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Impedance reflected to the primary by load Z_2 = 480 \u03a9\n",
+ "Case(b): Impedance reflected to the primary by load Z_3 = 60 \u03a9\n",
+ "Case(c): Total impedance reflected to the primary , Z_1 = 53.3 \u03a9\n",
+ "Case(d): Total current drawn from the supply , I_1 = 0.3 A\n",
+ "Case(e): Total power drawn from the supply at unity power factor , P_t = 4.8 W\n",
+ "Case(f): Voltage across load Z_2 , V_2 = 4 V\n",
+ " Power dissipated in load Z_2 , P_2 = 0.53 W\n",
+ "Case(g): Voltage across load Z_3 , V_3 = 8 V\n",
+ " Power dissipated in load Z_3 , P_3 = 4.27 W\n",
+ "Case(h): Total power dissipated in both loads , P_t = 4.8 W \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.5, Page number 491"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 100.0 #Power rating of the single channel power amplifier(W)\n",
+ "Z_p = 3200.0 #Output impedance ohm of the single channel power amplifier(ohm)\n",
+ "N_p = 1500.0 #Number of primary turns in a tapped impedance-matching transformer\n",
+ "Z_L1 = 8.0 #Amplifier output using a tapped impedance-matching transformer(ohm)\n",
+ "Z_L2 = 4.0 #Amplifier output using a tapped impedance-matching transformer(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "alpha = (Z_p/Z_L1)**0.5 #Transformation ratio\n",
+ "N_2 = N_p/alpha #Total number of secondary turns to match 8 ohm speaker\n",
+ "#Case(b)\n",
+ "alpha_b = (Z_p/Z_L2)**0.5 #Transformation ratio\n",
+ "N_1 = N_p/alpha_b #Number of primary turns to match 4 ohm speaker\n",
+ "#Case(c)\n",
+ "turns_difference = N_2-N_1 #Difference in secondary and primary turns\n",
+ "alpha_c = (N_p/turns_difference) #Transformation ratio\n",
+ "Z_L = Z_p/alpha_c**2 #Impedance that must be connected(ohm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Total number of secondary turns to match 8 \u03a9 impedance speaker , N_2 = %.f t' %N_2)\n",
+ "print('Case(b): Number of turns to match 4 \u03a9 impedance speaker , N_1 = %.f t' %N_1)\n",
+ "print('Case(c): Impedance that must be connected , Z_L = %.2f \u03a9' %Z_L)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Total number of secondary turns to match 8 \u03a9 impedance speaker , N_2 = 75 t\n",
+ "Case(b): Number of turns to match 4 \u03a9 impedance speaker , N_1 = 53 t\n",
+ "Case(c): Impedance that must be connected , Z_L = 0.69 \u03a9\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.6, Page number 492"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 100.0 #Power rating of the single channel power amplifier(W)\n",
+ "Z_L1 = 8.0 #Amplifier output using a tapped impedance-matching transformer(ohm)\n",
+ "Z_L2 = 4.0 #Amplifier output using a tapped impedance-matching transformer(ohm)\n",
+ "P_servo = 10.0 #Power rating of the servo motor(W)\n",
+ "Z_servo = 0.7 #Impedance of the servo motor(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "root_Z_AB = 8**0.5-4**0.5\n",
+ "Z_AB = (root_Z_AB)**2\n",
+ "\n",
+ "#Result\n",
+ "print('Impedance between terminals A and B , Z_AB = %.2f \u03a9' %Z_AB)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Impedance between terminals A and B , Z_AB = 0.69 \u03a9\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.7, Page number 494"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_s = 10.0*cmath.exp(1j*0*math.pi/180) #Supply voltage of the source(V)\n",
+ "R_s = 1000.0 #Resistance of the source(ohm)\n",
+ "R_L = 10.0 #Load resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "alpha = (R_s/R_L)**0.5 #Transformation ratio of the matching transformer for MPT\n",
+ "#Case(b)\n",
+ "V = abs(V_s) #Considering only absolute value of Supply voltage for easy simplification\n",
+ "V_1 = V/2 #Terminal voltage of the source at MPT(V)\n",
+ "#Case(c)\n",
+ "V_2 = V_1/alpha #Terminal voltage across the load at MPT(V)\n",
+ "#Case(d)\n",
+ "Z_L = R_L\n",
+ "I_2 = V_2/Z_L #Secondary load current(A). Method 1\n",
+ "I2 = V/(2*alpha*R_L) #Secondary load current(A). Method 2\n",
+ "#Case(e)\n",
+ "I_1 = I_2/alpha #Primary load current drawn from the source(A). Method 1\n",
+ "I1 = V/(2*R_s) #Primary load current drawn from the source(A). Method 2\n",
+ "#Case(f)\n",
+ "P_L = (I_2)**2*R_L #Maximum power dissipated in the load(W)\n",
+ "#Case(g)\n",
+ "P_s = (I_1)**2*R_s #Power dissipated internally within the source(W)\n",
+ "#Case(h)\n",
+ "theta = 0\n",
+ "P_T1 = abs(V)*I_1*math.cos(theta) #Total power supplied by the source(W). Method 1\n",
+ "P_T2 = P_L+P_s #Total power supplied by the source(W). Method 2\n",
+ "#Case(i)\n",
+ "P_T = P_T1\n",
+ "n = P_L/P_T*100 #Power transfer efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Transformation ratio of the matching transformer for MPT , \u03b1 = %.f ' %alpha)\n",
+ "print('Case(b): Terminal voltage of the source at MPT , V_1 = %.1f V' %V_1)\n",
+ "print('Case(c): Terminal voltage across the load at MPT , V_2 = %.1f V' %V_2)\n",
+ "print('Case(d): Secondary load current , I_2 = %.f mA (Method 1)' %(1000*I_2))\n",
+ "print(' Secondary load current , I_2 = %.f mA (Method 2)' %(1000*I2))\n",
+ "print('Case(e): Primary load current drawn from the source , I_1 = %.f mA (Method 1)' %(1000*I_1))\n",
+ "print(' Primary load current drawn from the source , I_1 = %.f mA (Method 2)' %(1000*I1))\n",
+ "print('Case(f): Maximum power dissipated in the load , P_L = %.f mW' %(1000*P_L))\n",
+ "print('Case(g): Power dissipated internally within the source , P_s = %.f mW' %(1000*P_s))\n",
+ "print('Case(h): Total power supplied by the source , P_T = %.f mW (Method 1)' %(1000*P_T1))\n",
+ "print(' Total power supplied by the source , P_T = %.f mW (Method 2)' %(1000*P_T2))\n",
+ "print('Case(i): Power transfer efficiency , \u03b7 = %.f percent' %n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Transformation ratio of the matching transformer for MPT , \u03b1 = 10 \n",
+ "Case(b): Terminal voltage of the source at MPT , V_1 = 5.0 V\n",
+ "Case(c): Terminal voltage across the load at MPT , V_2 = 0.5 V\n",
+ "Case(d): Secondary load current , I_2 = 50 mA (Method 1)\n",
+ " Secondary load current , I_2 = 50 mA (Method 2)\n",
+ "Case(e): Primary load current drawn from the source , I_1 = 5 mA (Method 1)\n",
+ " Primary load current drawn from the source , I_1 = 5 mA (Method 2)\n",
+ "Case(f): Maximum power dissipated in the load , P_L = 25 mW\n",
+ "Case(g): Power dissipated internally within the source , P_s = 25 mW\n",
+ "Case(h): Total power supplied by the source , P_T = 50 mW (Method 1)\n",
+ " Total power supplied by the source , P_T = 50 mW (Method 2)\n",
+ "Case(i): Power transfer efficiency , \u03b7 = 50 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.8, Page number 495"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 20.0 #No-load voltage(V)\n",
+ "R_s = 18.0 #Internal resistance of the power amplifier(ohm)\n",
+ "R_L = 8.0 #Load resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "V_L = (R_L/(R_L+R_s))* V #Load voltage(V)\n",
+ "P_L = (V_L)**2/R_L #Power delivered to the speaker when connected directly to the amplifier(W)\n",
+ "alpha = (R_s/R_L)**0.5 #Turns ratio of the transformer to maximize speaker power\n",
+ "V_2 = V/(2*alpha) #Secondary voltage(V)\n",
+ "P_L2 = (V_2)**2/R_L #Maximum power delivered to the speaker(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Power delivered to the speaker when connected directly to the amplifier , P_L = %.2f W' %P_L)\n",
+ "print('Case(b): Turns ratio of the transformer to maximize speaker power , \u03b1 = %.1f ' %alpha)\n",
+ "print('Case(c): Maximum power delivered to the speaker using matching transformer of part(b) , P_L = %.1f W' %P_L2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Power delivered to the speaker when connected directly to the amplifier , P_L = 4.73 W\n",
+ "Case(b): Turns ratio of the transformer to maximize speaker power , \u03b1 = 1.5 \n",
+ "Case(c): Maximum power delivered to the speaker using matching transformer of part(b) , P_L = 5.6 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.9, Page number 500"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 1.0 #Rating of the transformer(kVA)\n",
+ "V_1 = 220.0 #Primary voltage(V)\n",
+ "V_2 = 110.0 #Secondary voltage(V)\n",
+ "f_o = 400.0 #Original frequency(Hz)\n",
+ "f_f = 60.0 #Frequency for which the transformer is to be used(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "E_h = V_1*(f_f/f_o) #Maximum rms voltage applied to HV side(V)\n",
+ "E_1 = E_h\n",
+ "E_l = E_1/alpha #Maximum voltage output of LV side(V)\n",
+ "#Case(b)\n",
+ "V_h = V_1 #High voltage(V)\n",
+ "I_h = kVA*1000/V_h #High current(A)\n",
+ "Vh = E_h\n",
+ "kVA_new = Vh*I_h/1000 #kVA rating of transformer under reduced frequency\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Maximum rms voltage that may be applied to high-voltage side , E_h = %.f V' %E_h)\n",
+ "print(' Maximum voltage output of the low-voltage side , E_l = %.1f V' %E_l)\n",
+ "print('Case(b): kVA rating of transformer under conditions of reduced frequency , V_h*I_h = %.2f kVA' %kVA_new)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Maximum rms voltage that may be applied to high-voltage side , E_h = 33 V\n",
+ " Maximum voltage output of the low-voltage side , E_l = 16.5 V\n",
+ "Case(b): kVA rating of transformer under conditions of reduced frequency , V_h*I_h = 0.15 kVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.10, Page number 501"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 1.0 #kVA rating of the transformer\n",
+ "V_1 = 220.0 #Primary voltage(V)\n",
+ "V_2 = 110.0 #Secondary voltage(V)\n",
+ "f_o = 400.0 #Frequency(Hz)\n",
+ "f_f = 60.0 #Frequency for which the transformer is to be used(Hz)\n",
+ "P_orig = 10.0 #Original iron losses of the transformer(W)\n",
+ "\n",
+ "#Calculation \n",
+ "B = f_o/f_f #Flux density\n",
+ "P_iron = P_orig*B**2 #Iron losses(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Iron losses if is operated at reduced frequency of 60 Hz , P_iron = %.f W' %P_iron)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Iron losses if is operated at reduced frequency of 60 Hz , P_iron = 444 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.11, Page number 504"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "r_1 = 0.1 #Primary winding resistance(ohm)\n",
+ "x_1 = 0.3 #Primary winding reactance(ohm)\n",
+ "r_2 = 0.001 #Secondary winding resistance(ohm)\n",
+ "x_2 = 0.003 #Secondary winding reactance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "#Case(a)\n",
+ "I_2 = kVA*1000/V_2 #Secondary current(A)\n",
+ "I_1 = I_2/alpha #Primary current(A)\n",
+ "#Case(b)\n",
+ "Z_2 = complex(r_2,x_2) #Secondary internal impedance(ohm)\n",
+ "Z_2_m = abs(Z_2) #Magnitude of Z_2(ohm)\n",
+ "Z_1 = complex(r_1,x_1) #Primary internal impedance(ohm)\n",
+ "Z_1_m = abs(Z_1) #Magnitude of Z_1(ohm)\n",
+ "#Case(c)\n",
+ "I_2_Z_2 = I_2*Z_2_m #Secondary internal voltage drop(V)\n",
+ "I_1_Z_1 = I_1*Z_1_m #Primary internal voltage drop(V)\n",
+ "#Case(d)\n",
+ "E_2 = V_2+I_2_Z_2 #Secondary induced voltage(V)\n",
+ "E_1 = V_1-I_1_Z_1 #Primary induced voltage(V)\n",
+ "#Case(e)\n",
+ "ratio_E = E_1/E_2 #Ratio of primary to secondary induced voltage\n",
+ "ratio_V = V_1/V_2 #Ratio of primary to secondary terminal voltage\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Secondary current , I_2 = %.f A' %I_2)\n",
+ "print(' Primary current , I_1 = %.1f A' %I_1)\n",
+ "print('Case(b): Secondary internal impedance , Z_2 = %.5f \u03a9' %Z_2_m)\n",
+ "print(' Primary internal impedance , Z_1 = %.3f \u03a9' %Z_1_m)\n",
+ "print('Case(c): Secondary internal voltage drop , I_2*Z_2 = %.2f V' %I_2_Z_2)\n",
+ "print(' Primary internal voltage drop , I_1*Z_1 = %.1f V' %I_1_Z_1)\n",
+ "print('Case(d): Secondary induced voltage , E_2 = %.2f V' %E_2)\n",
+ "print(' Primary induced voltage , E_1 = %.1f V' %E_1)\n",
+ "print('Case(e): Ratio of primary to secondary induced voltages , E_1/E_2 = %.2f ' %ratio_E)\n",
+ "print(' Ratio of primary to secondary iterminal voltages , V_1/V_2 = %.1f ' %ratio_V)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Secondary current , I_2 = 2174 A\n",
+ " Primary current , I_1 = 217.4 A\n",
+ "Case(b): Secondary internal impedance , Z_2 = 0.00316 \u03a9\n",
+ " Primary internal impedance , Z_1 = 0.316 \u03a9\n",
+ "Case(c): Secondary internal voltage drop , I_2*Z_2 = 6.87 V\n",
+ " Primary internal voltage drop , I_1*Z_1 = 68.7 V\n",
+ "Case(d): Secondary induced voltage , E_2 = 236.87 V\n",
+ " Primary induced voltage , E_1 = 2231.3 V\n",
+ "Case(e): Ratio of primary to secondary induced voltages , E_1/E_2 = 9.42 \n",
+ " Ratio of primary to secondary iterminal voltages , V_1/V_2 = 10.0 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.12, Page number 505"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "I_2 = 2174.0 #Secondary current(A)\n",
+ "I_1 = 217.4 #Primary current(A)\n",
+ "Z_2 = 0.00316 #Secondary internal impedance(ohm)\n",
+ "Z_1 = 0.316 #Primary internal impedance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "#Case(a)\n",
+ "Z_L = V_2/I_2 #Load impedance(ohm)\n",
+ "#Case(b)\n",
+ "Z_p = V_1/I_1 #Primary input impedance(ohm)\n",
+ "Zp = alpha**2*Z_L #Primary input impedance(ohm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Load impedance , Z_L = %.4f \u03a9' %Z_L)\n",
+ "print('Case(b): Primary input impedance , Z_p = %.2f \u03a9 (Method 1)' %Z_p)\n",
+ "print(' Primary input impedance , Z_p = %.2f \u03a9 (Method 2)' %Zp)\n",
+ "print('Case(c): Impedance of load Z_L = %.4f \u03a9, is much greater than internal secondary impedance Z_2 = %.5f \u03a9' %(Z_L,Z_2))\n",
+ "print(' Primary input impedance Z_p = %.2f \u03a9, is much greater than the internal primary impedance Z_1 = %.3f \u03a9' %(Z_p,Z_1))\n",
+ "print('Case(d): Z_L must be much greater than Z_2 so that major part of the voltage produced by E_2 is dropped across Z_L')\n",
+ "print(' As Z_L is reduced in proportion to Z_2, the load current increases and more voltage is dropped internally across Z_2')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Load impedance , Z_L = 0.1058 \u03a9\n",
+ "Case(b): Primary input impedance , Z_p = 10.58 \u03a9 (Method 1)\n",
+ " Primary input impedance , Z_p = 10.58 \u03a9 (Method 2)\n",
+ "Case(c): Impedance of load Z_L = 0.1058 \u03a9, is much greater than internal secondary impedance Z_2 = 0.00316 \u03a9\n",
+ " Primary input impedance Z_p = 10.58 \u03a9, is much greater than the internal primary impedance Z_1 = 0.316 \u03a9\n",
+ "Case(d): Z_L must be much greater than Z_2 so that major part of the voltage produced by E_2 is dropped across Z_L\n",
+ " As Z_L is reduced in proportion to Z_2, the load current increases and more voltage is dropped internally across Z_2\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.13, Page number 505"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "r_1 = 0.1 #Primary winding resistance(ohm)\n",
+ "x_1 = 0.3 #Primary winding reactance(ohm)\n",
+ "r_2 = 0.001 #Secondary winding resistance(ohm)\n",
+ "x_2 = 0.003 #Secondary winding reactance(ohm)\n",
+ "Z_L = 0.1058 #Load impedance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "R_c1 = r_1+alpha**2*r_2 #Equivalent internal resistance referred to the primary side(ohm)\n",
+ "X_c1 = x_1+alpha**2*x_2 #Equivalent internal reactance referred to the primary side(ohm)\n",
+ "Z_c1 = complex(R_c1,X_c1) #Equivalent internal impedance referred to the primary side(ohm)\n",
+ "Z_c1_m = abs(Z_c1) #Magnitude of Z_e1(ohm)\n",
+ "Z_L_prime = alpha**2*Z_L #Equivalent secondary load impedance referred to the primary side(ohm)\n",
+ "R_L = Z_L #Load resistance(ohm)\n",
+ "X_L = 0 #Load reactance(ohm)\n",
+ "I_1 = V_1/complex((R_c1+alpha**2*R_L),(X_c1+alpha**2*X_L)) #Primary load current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent internal resistance referred to the primary side , R_c1 = %.1f \u03a9' %R_c1)\n",
+ "print('Case(b): Equivalent internal reactance referred to the primary side , X_c1 = %.1f \u03a9' %X_c1)\n",
+ "print('Case(c): Equivalent internal impedance referred to the primary side , Z_c1 = %.3f \u03a9' %Z_c1_m)\n",
+ "print('Case(d): Equivalent secondary load impedance referred to the primary side , \u03b1^2*Z_L = %.2f \u03a9' %Z_L_prime)\n",
+ "print('Case(e): Primary load current , I_1 = %.f A' %abs(I_1))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent internal resistance referred to the primary side , R_c1 = 0.2 \u03a9\n",
+ "Case(b): Equivalent internal reactance referred to the primary side , X_c1 = 0.6 \u03a9\n",
+ "Case(c): Equivalent internal impedance referred to the primary side , Z_c1 = 0.632 \u03a9\n",
+ "Case(d): Equivalent secondary load impedance referred to the primary side , \u03b1^2*Z_L = 10.58 \u03a9\n",
+ "Case(e): Primary load current , I_1 = 213 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.14, Page number 508"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "R_e2 = 2.0 #Equivalent resistance referred to the primary side(m\u03a9)\n",
+ "X_e2 = 6.0 #Equivalent reactance referred to the primary side(m\u03a9)\n",
+ "cos_theta2 = 1.0 #Unity PF\n",
+ "\n",
+ "#Calculation\n",
+ "I_2 = kVA/V_2 #Rated secondary current(kA)\n",
+ "R_e2_drop = I_2*R_e2 #Full-load equivalent resistance voltage drop(V)\n",
+ "X_e2_drop = I_2*X_e2 #Full-load equivalent reactance voltage drop(V) \n",
+ "sin_theta2 = (1-cos_theta2**2)**0.5\n",
+ "E_2 = complex((V_2*cos_theta2+I_2*R_e2),(V_2*sin_theta2+I_2*X_e2)) #Induced voltage(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "VR = (E_2_m-V_2)/V_2*100 #Percent voltage regulation at unity PF(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rated secondary current , I_2 = %.3f kA' %I_2)\n",
+ "print('Case(b): Full-load equivalent resistance voltage drop , I_2*R_e2 = %.2f V' %R_e2_drop)\n",
+ "print('Case(c): Full-load equivalent reactance voltage drop , I_2*X_e2 = %.2f V' %X_e2_drop)\n",
+ "print('Case(d): Induced voltage when the transformer is delivering rated current at unity PF , E_2 = %.2f V' %E_2_m)\n",
+ "print('Case(e): Voltage regulation at unity PF , VR = %.2f percent' %VR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rated secondary current , I_2 = 2.174 kA\n",
+ "Case(b): Full-load equivalent resistance voltage drop , I_2*R_e2 = 4.35 V\n",
+ "Case(c): Full-load equivalent reactance voltage drop , I_2*X_e2 = 13.04 V\n",
+ "Case(d): Induced voltage when the transformer is delivering rated current at unity PF , E_2 = 234.71 V\n",
+ "Case(e): Voltage regulation at unity PF , VR = 2.05 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.15, Page number 508"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "R_e2 = 2.0 #Equivalent resistance referred to the primary side(m\u03a9)\n",
+ "X_e2 = 6.0 #Equivalent reactance referred to the primary side(m\u03a9)\n",
+ "cos_theta2 = 0.8 #Lagging PF\n",
+ "\n",
+ "#Calculation\n",
+ "I_2 = kVA/V_2 #Rated secondary current(kA)\n",
+ "R_e2_drop = I_2*R_e2 #Full-load equivalent resistance voltage drop(V)\n",
+ "X_e2_drop = I_2*X_e2 #Full-load equivalent reactance voltage drop(V) \n",
+ "sin_theta2 = (1-cos_theta2**2)**0.5\n",
+ "E_2 = complex((V_2*cos_theta2+I_2*R_e2),(V_2*sin_theta2+I_2*X_e2)) #Induced voltage(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "VR = (E_2_m-V_2)/V_2*100 #Percent voltage regulation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(d): Induced voltage when the transformer is delivering rated current at 0.8 PF lagging , E_2 = %.2f V' %E_2_m)\n",
+ "print('Case(e): Voltage regulation at 0.8 PF lagging , VR = %.2f percent' %VR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(d): Induced voltage when the transformer is delivering rated current at 0.8 PF lagging , E_2 = 241.43 V\n",
+ "Case(e): Voltage regulation at 0.8 PF lagging , VR = 4.97 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.16, Page number 508"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "R_e2 = 2.0 #Equivalent resistance referred to the primary side(m\u03a9)\n",
+ "X_e2 = 6.0 #Equivalent reactance referred to the primary side(m\u03a9)\n",
+ "cos_theta2 = 0.6 #Leading PF\n",
+ "\n",
+ "#Calculation\n",
+ "I_2 = kVA/V_2 #Rated secondary current(kA)\n",
+ "R_e2_drop = I_2*R_e2 #Full-load equivalent resistance voltage drop(V)\n",
+ "X_e2_drop = I_2*X_e2 #Full-load equivalent reactance voltage drop(V) \n",
+ "sin_theta2 = (1-cos_theta2**2)**0.5\n",
+ "E_2 = complex((V_2*cos_theta2+I_2*R_e2),(V_2*sin_theta2-I_2*X_e2)) #Induced voltage(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "VR = (E_2_m-V_2)/V_2*100 #Percent voltage regulation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(d): Induced voltage when the transformer is delivering rated current at 0.6 PF leading , E_2 = %.1f V' %E_2_m)\n",
+ "print('Case(e): Voltage regulation at 0.6 PF leading , VR = %.2f percent' %VR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(d): Induced voltage when the transformer is delivering rated current at 0.6 PF leading , E_2 = 222.5 V\n",
+ "Case(e): Voltage regulation at 0.6 PF leading , VR = -3.28 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.17, Page number 511"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA = 20.0 #kVA rating of the step-down transformer\n",
+ "S = 20000.0 #Power rating of the step-down transformer in VA\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "P1 = 250.0 #Wattmeter reading(W)\n",
+ "I1 = 8.7 #Input current(A)\n",
+ "V1 = 50.0 #Input voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "#Case(a)\n",
+ "Z_e1 = V1/I1 #Equivalent impedance w.r.t HV side(ohm)\n",
+ "R_e1 = P1/I1**2 #Equivalent resistance w.r.t HV side(ohm)\n",
+ "theta = math.acos(R_e1/Z_e1) #PF angle(radians)\n",
+ "theta_a = theta*180/math.pi #PF angle(degree)\n",
+ "X_e1 = Z_e1*math.sin(theta) #Equivalent reactance w.r.t HV side(ohm)\n",
+ "#Case(b)\n",
+ "Z_e2 = Z_e1/alpha**2 #Equivalent impedance w.r.t LV side(ohm)\n",
+ "R_e2 = R_e1/alpha**2 #Equivalent resistance w.r.t LV side(ohm)\n",
+ "X_e2 = Z_e2*math.sin(theta) #Equivalent reactance w.r.t LV side(ohm)\n",
+ "#Case(c)\n",
+ "I_2 = S/V_2 #Rated secondary load current(A)\n",
+ "R_e2_drop = I_2*R_e2 #Full-load equivalent resistance voltage drop(V)\n",
+ "X_e2_drop = I_2*X_e2 #Full-load equivalent reactance voltage drop(V)\n",
+ "cos_theta2 = 1.0 #Unity PF\n",
+ "sin_theta2 = (1-cos_theta2**2)**0.5\n",
+ "E_2 = complex((V_2*cos_theta2+I_2*R_e2),(V_2*sin_theta2+I_2*X_e2)) #Induced voltage(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "VR_unity_PF = (E_2_m-V_2)/V_2*100 #Transformer voltage regulation(%)\n",
+ "#Case(d)\n",
+ "cos_theta_2 = 0.7 #Lagging PF\n",
+ "sin_theta_2 = (1-(cos_theta_2)**2)**0.5\n",
+ "E2 = complex((V_2*cos_theta_2+I_2*R_e2),(V_2*sin_theta_2+I_2*X_e2)) #Induced voltage(V)\n",
+ "E2_m = abs(E2) #Magnitude of E2(V)\n",
+ "VR_lag_PF = (E2_m-V_2)/V_2*100 #Transformer voltage regulation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent impedance referred to HV side , Z_e1 = %.2f \u03a9' %Z_e1)\n",
+ "print(' Equivalent resistance referred to HV side , R_e1 = %.1f \u03a9' %R_e1)\n",
+ "print(' Equivalent reactance referred to HV side , X_e1 = %.2f \u03a9' %X_e1)\n",
+ "print('Case(b): Equivalent impedance referred to LV side , Z_e2 = %.1f m\u03a9' %(1000*Z_e2))\n",
+ "print(' Equivalent resistance referred to LV side , R_e2 = %.f m\u03a9' %(1000*R_e2))\n",
+ "print(' Equivalent reactance referred to LV side , X_e2 = %.1f m\u03a9' %(1000*X_e2))\n",
+ "print('Case(c): Transformer voltage regulation , VR = %.2f percent' %VR_unity_PF)\n",
+ "print('Case(c): Transformer voltage regulation , VR = %.2f percent' %VR_lag_PF)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent impedance referred to HV side , Z_e1 = 5.75 \u03a9\n",
+ " Equivalent resistance referred to HV side , R_e1 = 3.3 \u03a9\n",
+ " Equivalent reactance referred to HV side , X_e1 = 4.70 \u03a9\n",
+ "Case(b): Equivalent impedance referred to LV side , Z_e2 = 57.5 m\u03a9\n",
+ " Equivalent resistance referred to LV side , R_e2 = 33 m\u03a9\n",
+ " Equivalent reactance referred to LV side , X_e2 = 47.0 m\u03a9\n",
+ "Case(c): Transformer voltage regulation , VR = 1.26 percent\n",
+ "Case(c): Transformer voltage regulation , VR = 2.14 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.18, Page number 511"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V1_rated = 2300.0 #Primary voltage(V)\n",
+ "V_sc = 50.0 #Short circuit test voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "Pc_sc_Pc = (V_sc/V1_rated)**2 #Fraction of rated core loss\n",
+ "\n",
+ "#Result\n",
+ "print('Fraction of P_c measured by wattmeter , P_c(sc) = %.6f*P_c ' %Pc_sc_Pc)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Fraction of P_c measured by wattmeter , P_c(sc) = 0.000473*P_c \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.19, Page number 512"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA = 20.0 #kVA rating of the step-down transformer\n",
+ "S = 20000.0 #Power rating of the step-down transformer in VA\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "P1 = 250.0 #Wattmeter reading(W)\n",
+ "I1 = 8.7 #Input current(A)\n",
+ "V1 = 50.0 #Input voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "I1_Ze1 = V1 #HV impedance drop(V)\n",
+ "#Case(b)\n",
+ "theta = math.acos(P1/(V1*I1)) #PF angle(radian)\n",
+ "theta_a = theta*180/math.pi #PF angle(degree)\n",
+ "I1_Re1 = I1_Ze1*math.cos(theta) #HV side resistance volt drop(V)\n",
+ "#Case(c)\n",
+ "I1_Xe1 = I1_Ze1*math.sin(theta) #HV side resistance volt drop(V)\n",
+ "#Case(d)\n",
+ "cos_theta1 = 1.0 #Unity PF\n",
+ "sin_theta1 = (1-cos_theta1**2)**0.5\n",
+ "E1 = complex((V_1*cos_theta1+I1_Re1),(V_1*sin_theta1+I1_Xe1)) #Induced voltage(V)\n",
+ "E1_m = abs(E1) #Magnitude of E1(V)\n",
+ "VR = (E1_m-V_1)/V_1*100 #Transformer voltage regulation at unity PF(%)\n",
+ "#Case(e)\n",
+ "cos_theta_1 = 0.7 #Lagging PF\n",
+ "sin_theta_1 = (1-cos_theta_1**2)**0.5\n",
+ "E_1 = complex((V_1*cos_theta_1+I1_Re1),(V_1*sin_theta_1+I1_Xe1)) #Induced voltage(V)\n",
+ "E_1_m = abs(E_1) #Magnitude of E_1(V)\n",
+ "VR_1 = (E_1_m-V_1)/V_1*100 #Transformer voltage regulation at 0.7 PF lagging(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): High voltage impedance drop , I_1*Z_e1 = %.f V' %I1_Ze1)\n",
+ "print('Case(b): HV side resistance volt drop , I_1*R_e1 = %.2f V' %I1_Re1)\n",
+ "print('Case(c): HV side reactance volt drop , I_1*X_e1 = %.2f V' %I1_Xe1)\n",
+ "print('Case(d): Transformer voltage regulation at unity PF , VR = %.2f percent' %VR)\n",
+ "print('Case(e): Transformer voltage regulation at 0.7 PF lagging , VR = %.2f percent' %VR_1)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): High voltage impedance drop , I_1*Z_e1 = 50 V\n",
+ "Case(b): HV side resistance volt drop , I_1*R_e1 = 28.74 V\n",
+ "Case(c): HV side reactance volt drop , I_1*X_e1 = 40.92 V\n",
+ "Case(d): Transformer voltage regulation at unity PF , VR = 1.27 percent\n",
+ "Case(e): Transformer voltage regulation at 0.7 PF lagging , VR = 2.15 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.20, Page number 515"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #kVA rating of the step-down transformer\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 208.0 #Secondary voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "P_sc = 8200.0 #Wattmeter reading in SC test(W)\n",
+ "I_sc = 217.4 #Short circuit current(A)\n",
+ "V_sc = 95.0 #Short circuit voltage(V)\n",
+ "P_oc = 1800.0 #Wattmeter reading in OC test(W)\n",
+ "I_oc = 85.0 #Open circuit current(A)\n",
+ "V_oc = 208.0 #Open circuit voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "#Case(a)\n",
+ "P = P_sc #Wattmeter reading(W)\n",
+ "I1 = I_sc #Short circuit current(A)\n",
+ "R_e1 = P/(I1)**2 #Equivalent resistance w.r.t HV side(ohm)\n",
+ "R_e2 = R_e1/alpha**2 #Equivalent resistance referred to LV side(ohm)\n",
+ "#Case(b)\n",
+ "r_2 = R_e2/2 #Resistance of low-voltage side(ohm)\n",
+ "#Case(c)\n",
+ "I_m = I_oc #Open circuit current(A)\n",
+ "P_cu = I_m**2*r_2 #Transformer copper loss of the LV side winding during OC-test(W)\n",
+ "#Case(d)\n",
+ "P_c = P_oc-P_cu #Transformer core loss(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent resistance to low voltage side , R_e2 = %.3f m\u03a9' %(1000*R_e2))\n",
+ "print('Case(b): Resistance of low voltage side , r_2 = %.2f m\u03a9' %(1000*r_2))\n",
+ "print('Case(c): Transformer copper loss of the LV side winding during OC-test , I_m^2*r_2 = %.2f W' %P_cu)\n",
+ "print('Case(d): Transformer core loss when rated voltage is applied , P_c = %.1f W' %P_c)\n",
+ "print('Case(e): Yes.The error is approximately 5/1800 = 0.278 percent, which is within error produced by the instruments used in test');\n",
+ "print(' We may assume that the core loss is %d W' %P_oc)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent resistance to low voltage side , R_e2 = 1.419 m\u03a9\n",
+ "Case(b): Resistance of low voltage side , r_2 = 0.71 m\u03a9\n",
+ "Case(c): Transformer copper loss of the LV side winding during OC-test , I_m^2*r_2 = 5.13 W\n",
+ "Case(d): Transformer core loss when rated voltage is applied , P_c = 1794.9 W\n",
+ "Case(e): Yes.The error is approximately 5/1800 = 0.278 percent, which is within error produced by the instruments used in test\n",
+ " We may assume that the core loss is 1800 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.21, Page number 516"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_sc = 50.0 #Short circuit voltage(V)\n",
+ "V_1 = 2300.0 #Rated primary voltage(V)\n",
+ "P_c = 1.8 #Core losses(kW)\n",
+ "P_k = 1.8 #Fixed losses(kW)\n",
+ "P_cu_rated = 8.2 #Rated copper loss(kW)\n",
+ "kVA = 500.0 #Power rating(kVA)\n",
+ "PF = 1.0 #Power factor\n",
+ "P_o = kVA*PF #Full-load output at unity PF(kW)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "LF1 = 1.0/4 #Load fraction\n",
+ "LF2 = 1.0/2 #Load fraction\n",
+ "LF3 = 3.0/4 #Load fraction\n",
+ "LF4 = 5.0/4 #Load fraction\n",
+ "P_cu_fl = 8.2 #Equivalent copper loss at full-load slip(kW)\n",
+ "P_cu_LF1 = LF1**2*P_cu_fl #Equivalent copper loss at 1/4 rated load(kW)\n",
+ "P_cu_LF2 = LF2**2*P_cu_fl #Equivalent copper loss at 1/2 rated load(kW)\n",
+ "P_cu_LF3 = LF3**2*P_cu_fl #Equivalent copper loss at 3/4 rated load(kW)\n",
+ "P_cu_LF4 = LF4**2*P_cu_fl ; #Equivalent copper loss at 5/4 rated load(kW)\n",
+ "P_L_fl = P_c+P_cu_fl #Total losses at rated load(kW)\n",
+ "P_L_1 = P_c+P_cu_LF1 #Total losses at 1/4 rated load(kW)\n",
+ "P_L_2 = P_c+P_cu_LF2 #Total losses at 1/2 rated load(kW)\n",
+ "P_L_3 = P_c+P_cu_LF3 #Total losses at 3/4 rated load(kW)\n",
+ "P_L_4 = P_c+P_cu_LF4 #Total losses at 5/4 rated load(kW)\n",
+ "P_o_fl = P_o #Total output at rated load(kW)\n",
+ "P_o_1 = P_o*LF1 #Total output at 1/4 rated load(kW)\n",
+ "P_o_2 = P_o*LF2 #Total output at 1/2 rated load(kW)\n",
+ "P_o_3 = P_o*LF3 #Total output at 3/4 rated load(kW)\n",
+ "P_o_4 = P_o*LF4 #Total output at 5/4 rated load(kW)\n",
+ "P_in_fl = P_L_fl+P_o_fl #Total input at rated load(kW)\n",
+ "P_in_1 = P_L_1+P_o_1 #Total input at 1/4 rated load(kW)\n",
+ "P_in_2 = P_L_2+P_o_2 #Total input at 1/2 rated load(kW)\n",
+ "P_in_3 = P_L_3+P_o_3 #Total input at 3/4 rated load(kW)\n",
+ "P_in_4 = P_L_4+P_o_4 #Total input at 5/4 rated load(kW)\n",
+ "n_fl = (P_o_fl/P_in_fl)*100 #Efficiency at rated load(%)\n",
+ "n_1 = (P_o_1/P_in_1)*100 #Efficiency at 1/4 rated load(%)\n",
+ "n_2 = (P_o_2/P_in_2)*100 #Efficiency at 1/2 rated load(%)\n",
+ "n_3 = (P_o_3/P_in_3)*100 #Efficiency at 3/4 rated load(%)\n",
+ "n_4 = (P_o_4/P_in_4)*100 #Efficiency at 5/4 rated load(%)\n",
+ "#Case(b)\n",
+ "PF_b = 0.8 #PF lagging\n",
+ "Po_fl = P_o*PF_b #Total output at 1rated load(kW)\n",
+ "Po_1 = P_o*LF1*PF_b #Total output at 1/4 rated load(kW)\n",
+ "Po_2 = P_o*LF2*PF_b #Total output at 1/2 rated load(kW)\n",
+ "Po_3 = P_o*LF3*PF_b #Total output at 3/4 rated load(kW)\n",
+ "Po_4 = P_o*LF4*PF_b #Total output at 5/4 rated load(kW)\n",
+ "Pin_fl = P_L_fl+Po_fl #Total input at rated load(kW)\n",
+ "Pin_1 = P_L_1+Po_1 #Total input at 1/4 rated load(kW)\n",
+ "Pin_2 = P_L_2+Po_2 #Total input at 1/2 rated load(kW)\n",
+ "Pin_3 = P_L_3+Po_3 #Total input at 3/4 rated load(kW)\n",
+ "Pin_4 = P_L_4+Po_4 #Total input at 5/4 rated load(kW)\n",
+ "nfl = (Po_fl/Pin_fl)*100 #Efficiency at rated load(%)\n",
+ "n1 = (Po_1/Pin_1)*100 #Efficiency at 1/4 rated load(%)\n",
+ "n2 = (Po_2/Pin_2)*100 #Efficiency at 1/2 rated load(%)\n",
+ "n3 = (Po_3/Pin_3)*100 #Efficiency at 3/4 rated load(%)\n",
+ "n4 = (Po_4/Pin_4)*100 #Efficiency at 5/4 rated load(%)\n",
+ "#Case(c)\n",
+ "R_e2 = 1.417*10**-3 #Equivalent resistance referred to LV side(ohm)\n",
+ "Pc = 1800.0 #Core losses(W)\n",
+ "I_2 = (Pc/R_e2)**0.5 #Load current for maximum efficiency invariant of LF(A)\n",
+ "#Case(d)\n",
+ "V = 208.0 #Voltage rating(V)\n",
+ "I_2_rated = kVA*1000/V #Rated secondary current(A)\n",
+ "LF_max = I_2/I_2_rated #Load fraction for maximum efficiency\n",
+ "#Case(e)\n",
+ "cos_theta = 1.0 #Unity PF\n",
+ "V_2 = V #Secondary voltage(V)\n",
+ "n_max_e = (V_2*I_2*cos_theta)/((V_2*I_2*cos_theta)+(Pc+I_2**2*R_e2))*100 #Maximum efficiency(%)\n",
+ "#Case(f)\n",
+ "cos_theta2 = 0.8 #PF lagging\n",
+ "n_max_f = (V_2*I_2*cos_theta2)/((V_2*I_2*cos_theta2)+(Pc+I_2**2*R_e2))*100 #Maximum efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Tabulation at unity PF:')\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('L.F \\t Core loss \\t Copper loss \\tTotal loss \\t Total Output \\t Total Input \\t Efficiency')\n",
+ "print(' \\t (kW) \\t (kW) \\t P_L (kW) \\t P_o(kW) \\t P_L+P_o(kW) \\t P_o/P_in(percent)')\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.3f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF1,P_c,P_cu_LF1,P_L_1,P_o_1,P_in_1,n_1))\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.2f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF2,P_c,P_cu_LF2,P_L_2,P_o_2,P_in_2,n_2))\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.2f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF3,P_c,P_cu_LF3,P_L_3,P_o_3,P_in_3,n_3))\n",
+ "print('1 \\t %.1f \\t\\t %.3f \\t %.2f \\t\\t %.1f \\t %.1f \\t %.2f' %(P_c,P_cu_fl,P_L_fl,P_o_fl,P_in_fl,n_fl))\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.1f \\t\\t %.1f \\t %.1f \\t %.2f' %(LF4,P_c,P_cu_LF4,P_L_4,P_o_4,P_in_4,n_4))\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('\\nCase(b): Tabulation at 0.8 PF lagging:')\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('L.F \\t Core loss \\t Copper loss \\tTotal loss \\t Total Output \\t Total Input \\t Efficiency')\n",
+ "print('\\t (kW) \\t (kW) \\t P_L (kW) \\t P_o(kW) \\t P_L+P_o(kW)\\t P_o/P_in(percent)')\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.3f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF1,P_c,P_cu_LF1,P_L_1,Po_1,Pin_1,n1))\n",
+ "print('%.2f \\t %.1f \\t\\t %.2f \\t %.2f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF2,P_c,P_cu_LF2,P_L_2,Po_2,Pin_2,n2))\n",
+ "print('%.2f \\t %.1f \\t\\t %.2f \\t %.2f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF3,P_c,P_cu_LF3,P_L_3,Po_3,Pin_3,n3))\n",
+ "print('1 \\t %.1f \\t\\t %.1f \\t\\t %.2f \\t\\t %.1f \\t %.f \\t\\t %.2f' %(P_c,P_cu_fl,P_L_fl,Po_fl,Pin_fl,nfl))\n",
+ "print('%.2f \\t %.1f \\t\\t %.1f \\t %.1f \\t\\t %.1f \\t %.1f \\t %.2f' %(LF4,P_c,P_cu_LF4,P_L_4,Po_4,Pin_4,n4))\n",
+ "print('__________________________________________________________________________________________________________\\n')\n",
+ "print('Case(c): Load current at which maximum efficiency occurs regardless of load PF , I_2 = %.1f A' %I_2)\n",
+ "print('Case(d): Load fraction at which maximum efficiency occurs = %.3f (approximately half rated load)' %LF_max)\n",
+ "print('Case(e): Maximum efficiency at unity PF , \u03b7_max = %.2f percent' %n_max_e)\n",
+ "print('Case(f): Maximum efficiency at 0.8 PF lagging , \u03b7_max = %.2f percent' %n_max_f)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Tabulation at unity PF:\n",
+ "__________________________________________________________________________________________________________\n",
+ "L.F \t Core loss \t Copper loss \tTotal loss \t Total Output \t Total Input \t Efficiency\n",
+ " \t (kW) \t (kW) \t P_L (kW) \t P_o(kW) \t P_L+P_o(kW) \t P_o/P_in(percent)\n",
+ "__________________________________________________________________________________________________________\n",
+ "0.25 \t 1.8 \t\t 0.512 \t 2.312 \t\t 125.0 \t 127.31 \t 98.18\n",
+ "0.50 \t 1.8 \t\t 2.050 \t 3.85 \t\t 250.0 \t 253.85 \t 98.48\n",
+ "0.75 \t 1.8 \t\t 4.612 \t 6.41 \t\t 375.0 \t 381.41 \t 98.32\n",
+ "1 \t 1.8 \t\t 8.200 \t 10.00 \t\t 500.0 \t 510.0 \t 98.04\n",
+ "1.25 \t 1.8 \t\t 12.812 \t 14.6 \t\t 625.0 \t 639.6 \t 97.72\n",
+ "__________________________________________________________________________________________________________\n",
+ "\n",
+ "Case(b): Tabulation at 0.8 PF lagging:\n",
+ "__________________________________________________________________________________________________________\n",
+ "L.F \t Core loss \t Copper loss \tTotal loss \t Total Output \t Total Input \t Efficiency\n",
+ "\t (kW) \t (kW) \t P_L (kW) \t P_o(kW) \t P_L+P_o(kW)\t P_o/P_in(percent)\n",
+ "__________________________________________________________________________________________________________\n",
+ "0.25 \t 1.8 \t\t 0.512 \t 2.312 \t\t 100.0 \t 102.31 \t 97.74\n",
+ "0.50 \t 1.8 \t\t 2.05 \t 3.85 \t\t 200.0 \t 203.85 \t 98.11\n",
+ "0.75 \t 1.8 \t\t 4.61 \t 6.41 \t\t 300.0 \t 306.41 \t 97.91\n",
+ "1 \t 1.8 \t\t 8.2 \t\t 10.00 \t\t 400.0 \t 410 \t\t 97.56\n",
+ "1.25 \t 1.8 \t\t 12.8 \t 14.6 \t\t 500.0 \t 514.6 \t 97.16\n",
+ "__________________________________________________________________________________________________________\n",
+ "\n",
+ "Case(c): Load current at which maximum efficiency occurs regardless of load PF , I_2 = 1127.1 A\n",
+ "Case(d): Load fraction at which maximum efficiency occurs = 0.469 (approximately half rated load)\n",
+ "Case(e): Maximum efficiency at unity PF , \u03b7_max = 98.49 percent\n",
+ "Case(f): Maximum efficiency at 0.8 PF lagging , \u03b7_max = 98.12 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.22, Page number 520"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "P = 20.0 #Power rating of the transformer(kVA)\n",
+ "P_sc = 250.0 #Power measured(W)\n",
+ "V_sc = 50.0 #Short circuit voltage(V)\n",
+ "I_sc = 8.7 #Short circuit current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_1b = V_1 #Base voltage(V)\n",
+ "Z_eq_pu = V_sc/V_1\n",
+ "beta = math.acos(P_sc/(V_sc*I_sc)) #Angle(radian)\n",
+ "beta_a = beta*180/math.pi #Angle(degree)\n",
+ "Zeq_pu = Z_eq_pu*cmath.exp(1j*beta) #Equivalent pu impedance\n",
+ "#Case(b)\n",
+ "PF_b = 1.0 #Unity PF\n",
+ "theta_b = math.acos(PF_b)*180/math.pi #PF angle(degree)\n",
+ "V_1_pu = 1.0*cmath.exp(1j*0*math.pi/180)+1.0*cmath.exp(1j*theta_b*math.pi/180)*Zeq_pu #pu voltage\n",
+ "V_1_pu_m = abs(V_1_pu) #Magnitude of V_1_pu\n",
+ "#Case(c)\n",
+ "theta = math.acos(0.7)*180/math.pi #Power factor angle(degrees)\n",
+ "V1_pu = 1.0*cmath.exp(1j*0*math.pi/180)+1.0*cmath.exp(1j*(-theta)*math.pi/180)*Zeq_pu #pu voltage\n",
+ "V1_pu_m = abs(V1_pu) #Magnitude of V1_pu\n",
+ "#Case(d)\n",
+ "VR_unity_PF = (V_1_pu_m-1.0)*100 #Voltage regulation at unity PF(%)\n",
+ "#Case(e)\n",
+ "VR_lag_PF = (V1_pu_m-1.0)*100 #Voltage regulation at 0.7 lagging PF(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Z_eq(pu)\u2220\u03b2 = %.5f\u2220%.f\u00b0 p.u' %(abs(Z_eq_pu),beta_a))\n",
+ "print('Case(b): V_1(pu) at unity PF , |V_1(pu)| = %.4f ' %V_1_pu_m)\n",
+ "print('Case(c): V_1(pu) at 0.7 PF lagging , |V_1(pu)| = %.5f ' %V1_pu_m)\n",
+ "print('Case(d): Voltage regulation at unity PF , VR = %.2f percent' %VR_unity_PF)\n",
+ "print('Case(e): Voltage regulation at 0.7 PF lagging , VR = %.2f percent' %VR_lag_PF)\n",
+ "print('Case(f): VRs as found by p.u method are essentially the same as those found in Exs.14-17 and 14-19 using the same data, for the same transformer but with much less effort')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Z_eq(pu)\u2220\u03b2 = 0.02174\u222055\u00b0 p.u\n",
+ "Case(b): V_1(pu) at unity PF , |V_1(pu)| = 1.0127 \n",
+ "Case(c): V_1(pu) at 0.7 PF lagging , |V_1(pu)| = 1.02146 \n",
+ "Case(d): Voltage regulation at unity PF , VR = 1.27 percent\n",
+ "Case(e): Voltage regulation at 0.7 PF lagging , VR = 2.15 percent\n",
+ "Case(f): VRs as found by p.u method are essentially the same as those found in Exs.14-17 and 14-19 using the same data, for the same transformer but with much less effort\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.23, Page number 521"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "S = 500.0 #Power rating of the transformer(kVA)\n",
+ "f= 60.0 #Frequency(Hz)\n",
+ "V_oc = 208.0 #Open circuit voltage(V)\n",
+ "I_oc = 85.0 #Open circuit current(A)\n",
+ "P_oc = 1800.0 #Power measured(W)\n",
+ "V_sc = 95.0 #Short circuit voltage(V)\n",
+ "I_sc = 217.4 #Short circuit current(A)\n",
+ "P_sc = 8200.0 #Power measured(W)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "S_b = S ; #Base voltage(kVA)\n",
+ "Psc = 8.2 #Power measured in kW during SC-test\n",
+ "P_Cu_pu = Psc/S_b #Per unit value of P_Cu at rated load\n",
+ "#Case(b)\n",
+ "Poc = 1.8 #Power measured during OC-test(kW)\n",
+ "P_CL_pu = Poc/S_b #Per unit value of P_CL at rated load\n",
+ "#Case(c)\n",
+ "PF = 1.0 #Unity Power factor\n",
+ "n_pu = PF/(PF+P_CL_pu+P_Cu_pu)*100 #Efficiency at rated load,unity PF(%)\n",
+ "#Case(d)\n",
+ "PF_d = 0.8 #Lagging Power factor\n",
+ "n_pu_d = PF_d/(PF_d+P_CL_pu+P_Cu_pu)*100 #Efficiency at rated load,0.8 lagging PF\n",
+ "#Case(e)\n",
+ "LF = (P_CL_pu/P_Cu_pu)**0.5 #Load fraction producing maximum efficiency\n",
+ "#Case(f)\n",
+ "n_pu_max = (LF*PF)/((LF*PF)+2*(P_CL_pu))*100 #Maximum efficiency at unity PF load\n",
+ "#Case(f)\n",
+ "n_pu_max_g = (LF*PF_d)/((LF*PF_d)+2*(P_CL_pu))*100 #Maximum efficiency at 0.8 lagging PF load\n",
+ "\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Per unit copper loss at rated load , P_Cu(pu) = %.4f p.u = R_eq(pu)' %P_Cu_pu)\n",
+ "print('Case(b): Per unit core loss at rated load , P_CL(pu) = %.4f p.u' %P_CL_pu)\n",
+ "print('Case(c): Efficiency at rated load, unity PF , \u03b7_pu = %.2f percent' %n_pu)\n",
+ "print('Case(d): Efficiency at rated load, 0.8 PF lagging , \u03b7_pu = %.2f percent' %n_pu_d)\n",
+ "print('Case(e): Load fraction producing maximum efficiency , L.F = %.3f ' %LF)\n",
+ "print('Case(f): Maximum efficiency at unity PF load , \u03b7_pu = %.2f percent' %n_pu_max)\n",
+ "print('Case(g): Maximum efficiency at 0.8 PF lagging , \u03b7_pu = %.2f percent' %n_pu_max_g)\n",
+ "print('Case(h): All efficiency values are identical to those computed in solution to Ex.14-21')\n",
+ "print('Case(i): Per-unit method is much simpler and less subject to error than conventional method')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Per unit copper loss at rated load , P_Cu(pu) = 0.0164 p.u = R_eq(pu)\n",
+ "Case(b): Per unit core loss at rated load , P_CL(pu) = 0.0036 p.u\n",
+ "Case(c): Efficiency at rated load, unity PF , \u03b7_pu = 98.04 percent\n",
+ "Case(d): Efficiency at rated load, 0.8 PF lagging , \u03b7_pu = 97.56 percent\n",
+ "Case(e): Load fraction producing maximum efficiency , L.F = 0.469 \n",
+ "Case(f): Maximum efficiency at unity PF load , \u03b7_pu = 98.49 percent\n",
+ "Case(g): Maximum efficiency at 0.8 PF lagging , \u03b7_pu = 98.12 percent\n",
+ "Case(h): All efficiency values are identical to those computed in solution to Ex.14-21\n",
+ "Case(i): Per-unit method is much simpler and less subject to error than conventional method\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.24, Page number 521"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "S = 500.0 #Power rating of the transformer(kVA)\n",
+ "f= 60.0 #Frequency(Hz)\n",
+ "V_oc = 208.0 #Open circuit voltage(V)\n",
+ "I_oc = 85.0 #Open circuit current(A)\n",
+ "P_oc = 1800.0 #Power measured(W)\n",
+ "V_sc = 95.0 #Short circuit voltage(V)\n",
+ "I_sc = 217.4 #Short circuit current(A)\n",
+ "P_sc = 8200.0 #Power measured(W)\n",
+ "\n",
+ "#Calculation\n",
+ "S_b = S ; #Base voltage(kVA)\n",
+ "Psc = 8.2 #Power measured in kW during SC-test\n",
+ "P_Cu_pu = Psc/S_b #Per unit value of P_Cu at rated load\n",
+ "Poc = 1.8 #Power measured during OC-test(kW)\n",
+ "P_CL_pu = Poc/S_b #Per unit value of P_CL at rated load\n",
+ "#Case(a)\n",
+ "LF1 = 3.0/4 #Load fraction of rated load \n",
+ "PF1 = 1.0 #Unity Power factor\n",
+ "n_pu_LF1 = (LF1*PF1)/((LF1*PF1)+P_CL_pu+(LF1)**2*P_Cu_pu)*100 #Efficiency at rated load,unity PF(%)\n",
+ "#Case(b)\n",
+ "LF2 = 1.0/4 #Load fraction of rated load\n",
+ "PF2 = 0.8 #Lagging PF\n",
+ "n_pu_LF2 = (LF2*PF2)/((LF2*PF2)+P_CL_pu+(LF2)**2*P_Cu_pu)*100 #Efficiency at 1/4 rated load,0.8 lagging PF(%)\n",
+ "#Case(c)\n",
+ "LF3 = 5.0/4 #Load fraction of rated load\n",
+ "PF3 = 0.8 #Leading PF\n",
+ "n_pu_LF3 = (LF3*PF3)/((LF3*PF3)+P_CL_pu+(LF3)**2*P_Cu_pu)*100 #Efficiency at r1/4 rated load,0.8 leading PF(%)\n",
+ "\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): p.u efficiency at 3/4 load unity PF , \u03b7_pu = %.2f percent' %n_pu_LF1)\n",
+ "print('Case(b): p.u efficiency at 1/4 load 0.8 PF lagging , \u03b7_pu = %.2f percent' %n_pu_LF2)\n",
+ "print('Case(c): p.u efficiency at 5/4 load 0.8 PF leading , \u03b7_pu = %.2f percent' %n_pu_LF3)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): p.u efficiency at 3/4 load unity PF , \u03b7_pu = 98.32 percent\n",
+ "Case(b): p.u efficiency at 1/4 load 0.8 PF lagging , \u03b7_pu = 97.74 percent\n",
+ "Case(c): p.u efficiency at 5/4 load 0.8 PF leading , \u03b7_pu = 97.16 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.25, Page number 522"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA_1 = 500.0 #Power rating of the transformer 1(kVA)\n",
+ "R_1_pu = 0.01 #Per-unit value of resistance of the transformer 1\n",
+ "X_1_pu = 0.05 #Per-unit value of reactance of the transformer 1\n",
+ "Z_1_pu = complex(R_1_pu,X_1_pu) #Per-unit value of impedance of the transformer 1\n",
+ "PF = 0.8 #Lagging PF\n",
+ "V_2 = 400.0 #Secondary voltage(V)\n",
+ "S_load = 750.0 #Increased system load(kVA)\n",
+ "kVA_2 = 250.0 #Power rating of the transformer 2(kVA)\n",
+ "R_pu_2 = 0.015 #Per-unit value of resistance of the transformer 2\n",
+ "X_pu_2 = 0.04 #Per-unit value of reactance of the transformer 2\n",
+ "\n",
+ "#Calculation\n",
+ "Z_pu_1 = complex(R_pu_2,X_pu_2) #New transformer p.u. impedance\n",
+ "#Case(a)\n",
+ "V_b1 = 400.0 #Base voltage(V)\n",
+ "V_b2 = 400.0 #Base voltage(V)\n",
+ "Z_pu_2 = (kVA_1/kVA_2)*(V_b1/V_b2)**2*(Z_pu_1) #New transformer p.u impedance\n",
+ "Z_2_pu = Z_pu_2 #New transformer p.u impedance\n",
+ "#Case(b)\n",
+ "cos_theta = PF #Power factor\n",
+ "sin_theta = (1-(cos_theta)**2)**0.5\n",
+ "S_t_conjugate = (kVA_1+kVA_2)*complex(cos_theta,sin_theta) #kVA of total load\n",
+ "#Case(c)\n",
+ "S_2_conjugate = S_t_conjugate*(Z_1_pu/(Z_1_pu+Z_2_pu)) #Portion of load carried by the smaller transformer(kVA)\n",
+ "S_2_conjugate_m = abs(S_2_conjugate) #Magnitude of S_2_conjugate(kVA)\n",
+ "S_2_conjugate_a = cmath.phase(S_2_conjugate)*180/math.pi #Phase angle of S_2_conjugate(degree)\n",
+ "#Case(d)\n",
+ "S_1_conjugate = S_t_conjugate*(Z_2_pu/(Z_1_pu+Z_2_pu)) #Portion of load carried by the original transformer(kVA)\n",
+ "S_1_conjugate_m = abs(S_1_conjugate) #Magnitude of S_1_conjugate(kVA)\n",
+ "S_1_conjugate_a = cmath.phase(S_1_conjugate)*180/math.pi #Phase angle of S_1_conjugate(degree)\n",
+ "#Case(e)\n",
+ "S_1 = S_1_conjugate_m\n",
+ "S_b1 = kVA_1 #Base power of trancsformer 1(kVA)\n",
+ "LF1 = (S_1/S_b1)*100 #Load factor of the original transformer(%)\n",
+ "#Case(f)\n",
+ "S_2 = S_2_conjugate_m\n",
+ "S_b2 = kVA_2 #Base power of trancsformer 1(kVA)\n",
+ "LF2 = (S_2/S_b2)*100 #Load factor of the new transformer(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): New transformer p.u impedance , Z_p.u.2 = (%.2f+j%.2f) p.u' %(Z_pu_2.real,Z_pu_2.imag))\n",
+ "print('Case(b): kVA of total load , S*_t = (%.f+j%.f) kVA ' %(S_t_conjugate.real,S_t_conjugate.imag))\n",
+ "print('Case(c): Portion of load now carried by the smaller transformer , S*_2 = (%.2f+j%.2f) kVA = %.1f\u2220%.1f\u00b0 kVA' %(S_2_conjugate.real,S_2_conjugate.imag,S_2_conjugate_m,S_2_conjugate_a))\n",
+ "print('Case(d): Portion of load now carried by the original transformer , S*_1 = (%.2f+j%.1f) kVA = %.1f\u2220%.1f\u00b0 kVA' %(S_1_conjugate.real,S_1_conjugate.imag,S_1_conjugate_m,S_1_conjugate_a))\n",
+ "print('Case(e): Load factor of the original transformer , L.F_1 = %.1f percent' %LF1)\n",
+ "print('Case(f): Load factor of the new transformer , L.F_w = %.1f percent' %LF2)\n",
+ "print('Case(g): Yes. Reduce no-load voltage of the new transformer to some value below that of its present value so that its share of the load is reduced')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): New transformer p.u impedance , Z_p.u.2 = (0.03+j0.08) p.u\n",
+ "Case(b): kVA of total load , S*_t = (600+j450) kVA \n",
+ "Case(c): Portion of load now carried by the smaller transformer , S*_2 = (206.76+j190.54) kVA = 281.2\u222042.7\u00b0 kVA\n",
+ "Case(d): Portion of load now carried by the original transformer , S*_1 = (393.24+j259.5) kVA = 471.1\u222033.4\u00b0 kVA\n",
+ "Case(e): Load factor of the original transformer , L.F_1 = 94.2 percent\n",
+ "Case(f): Load factor of the new transformer , L.F_w = 112.5 percent\n",
+ "Case(g): Yes. Reduce no-load voltage of the new transformer to some value below that of its present value so that its share of the load is reduced\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.26, Page number 523"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA_1 = 500.0 #Power rating of the transformer 1(kVA)\n",
+ "R_1_pu = 0.01 #Per-unit value of resistance of the transformer 1\n",
+ "X_1_pu = 0.05 #Per-unit value of reactance of the transformer 1\n",
+ "Z_1_pu = complex(R_1_pu,X_1_pu) #Per-unit value of impedance of the transformer 1\n",
+ "PF = 0.8 #Lagging PF\n",
+ "V = 400.0 #Secondary voltage(V)\n",
+ "S_load = 750.0 #Increased system load(kVA)\n",
+ "kVA_2 = 250.0 #Power rating of the transformer 2(kVA)\n",
+ "R_pu_2 = 0.015 #Per-unit value of resistance of the transformer 2\n",
+ "X_pu_2 = 0.04 #Per-unit value of reactance of the transformer 2\n",
+ "\n",
+ "#Calculation\n",
+ "Z_pu_1 = complex(R_1_pu,X_1_pu) #New transformer p.u. impedance\n",
+ "Z_pu1 = complex(R_pu_2,X_pu_2) #New transformer p.u. impedance\n",
+ "#Case(a)\n",
+ "V_b = V #Base voltage(V)\n",
+ "#Case(b)\n",
+ "S_b = kVA_1 #Base power(kVA)\n",
+ "I_b = S_b/V_b*1000 #Base current(A)\n",
+ "#Case(c)\n",
+ "Zb = V_b/I_b #Base impedance(ohm). Method 1\n",
+ "Z_b = V**2/(S_b*1000) #Base impedance(ohm). Method 2\n",
+ "#Case(d)\n",
+ "Z_1 = Z_b*Z_pu_1*1000 #Actual impedance of larger transformer(m\u03a9)\n",
+ "Z_1_m = abs(Z_1) #Magnitude of Z_1(\u03a9)\n",
+ "Z_1_a = cmath.phase(Z_1)*180/math.pi #Phase angle of Z_1(degree)\n",
+ "#Case(e)\n",
+ "V_b1 = V_b #Base voltage(V)\n",
+ "V_b2 = V_b #Base voltage(V)\n",
+ "Z_pu_2 = (kVA_1/kVA_2)*(V_b1/V_b2)**2*(Z_pu1) #New transformer p.u impedance\n",
+ "Z_2_pu = Z_pu_2\n",
+ "Z_2 = Z_b*Z_2_pu*1000 #Actual impedance of smaller transformer(m\u03a9)\n",
+ "Z_2_m = abs(Z_2) #Magnitude of Z_2(\u03a9)\n",
+ "Z_2_a = cmath.phase(Z_2)*180/math.pi #Phase angle of Z_2(degree)\n",
+ "#Case(f)\n",
+ "cos_theta = 0.8 #Lagging power factor\n",
+ "sin_theta = (1-(cos_theta)**2)**0.5\n",
+ "S_T = (kVA_1+kVA_2)*complex(cos_theta,-sin_theta) #kVA of total load\n",
+ "I_T = S_T*1000/V_b #Total current(A)\n",
+ "I_1 = I_T*(Z_2/(Z_1+Z_2)) #Actual current delivered by larger transformer(A)\n",
+ "I_1_m = abs(I_1) #Magnitude of I_1(A)\n",
+ "I_1_a = cmath.phase(I_1)*180/math.pi #Phase angle of I_1(degree)\n",
+ "#Case(g)\n",
+ "I_2 = I_T*(Z_1/(Z_1+Z_2)) #Actual current delivered by smaller transformer(A)\n",
+ "I_2_m = abs(I_2) #Magnitude of I_2(A)\n",
+ "I_2_a = cmath.phase(I_2)*180/math.pi #Phase angle of I_2(degree)\n",
+ "#Case(h)\n",
+ "Z1 = Z_1/1000 #Actual impedance of larger transformer(\u03a9)\n",
+ "E_1 = I_1*Z1+V_b #No-load voltage of larger transformer(V)\n",
+ "E_1_m = abs(E_1) #Magnitude of E_1(V)\n",
+ "E_1_a = cmath.phase(E_1)*180/math.pi #Phase angle of E_1(degree)\n",
+ "#Case(i)\n",
+ "Z2 = Z_2/1000 #Actual impedance of smaller transformer(\u03a9)\n",
+ "E_2 = I_2*Z2+V_b #No-load voltage of smaller transformer(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "E_2_a = cmath.phase(E_2)*180/math.pi #Phase angle of E_2(degree)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Base voltage , V_b = %.f V' %V_b)\n",
+ "print('Case(b): Base current , I_b = %.2f kA' %(I_b/1000))\n",
+ "print('Case(c): Base impedance , Z_b = %.2f \u03a9 (Method 1)' %Zb)\n",
+ "print(' Base impedance , Z_b = %.2f \u03a9 (Method 2)' %Z_b)\n",
+ "print('Case(d): Actual impedance of larger transformer , Z_1 = %.2f\u2220%.1f\u00b0 m\u03a9' %(Z_1_m,Z_1_a))\n",
+ "print('Case(e): Actual impedance of smaller transformer , Z_2 = %.2f\u2220%.2f\u00b0 m\u03a9' %(Z_2_m,Z_2_a))\n",
+ "print('Case(f): Actual current delivered by larger transformer , I_1 = %.f\u2220%.2f\u00b0 A' %(I_1_m,I_1_a))\n",
+ "print('Case(g): Actual current delivered by smaller transformer , I_2 = %.1f\u2220%.1f\u00b0 A' %(I_2_m,I_2_a))\n",
+ "print('Case(h): No-load voltage of larger transformer , E_1 = %.2f\u2220%.2f\u00b0 V' %(E_1_m,E_1_a))\n",
+ "print('Case(i): No-load voltage of smaller transformer , E_2 = %.2f\u2220%.2f\u00b0 V' %(E_2_m,E_2_a))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Base voltage , V_b = 400 V\n",
+ "Case(b): Base current , I_b = 1.25 kA\n",
+ "Case(c): Base impedance , Z_b = 0.32 \u03a9 (Method 1)\n",
+ " Base impedance , Z_b = 0.32 \u03a9 (Method 2)\n",
+ "Case(d): Actual impedance of larger transformer , Z_1 = 16.32\u222078.7\u00b0 m\u03a9\n",
+ "Case(e): Actual impedance of smaller transformer , Z_2 = 27.34\u222069.44\u00b0 m\u03a9\n",
+ "Case(f): Actual current delivered by larger transformer , I_1 = 1178\u2220-40.32\u00b0 A\n",
+ "Case(g): Actual current delivered by smaller transformer , I_2 = 702.9\u2220-31.1\u00b0 A\n",
+ "Case(h): No-load voltage of larger transformer , E_1 = 415.24\u22201.65\u00b0 V\n",
+ "Case(i): No-load voltage of smaller transformer , E_2 = 415.24\u22201.65\u00b0 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.27, Page number 525"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P_L = 14400.0 #Load output power(W)\n",
+ "V_L = 120.0 #Load voltage(V)\n",
+ "V_b1 = 120.0 #Base voltage at point 1(V)\n",
+ "V_b2 = 600.0 #Base voltage at point 2(V)\n",
+ "V_b3 = 120.0 #Base voltage at point 3(V)\n",
+ "S_b3 = 14.4 #Base power(kVA)\n",
+ "X_2 = 0.25 #Reactance(p.u)\n",
+ "X_1 = 0.2 #Reactance(p.u)\n",
+ "I_L = 120.0 #Load current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "R_L = P_L/(V_L**2) #Resistance of the load(ohm)\n",
+ "#Case(b)\n",
+ "Z_bL = (V_b3**2)/(S_b3*1000) #Base impedance(ohm)\n",
+ "#Case(c)\n",
+ "Z_L_pu = R_L/Z_bL #Per unit load impedance \n",
+ "#Case(d)\n",
+ "Z_2_pu = complex(0,X_2) #Per unit impedance of T2\n",
+ "#Case(e)\n",
+ "Z_1_pu = complex(0,X_1) #Per unit impedance of T1\n",
+ "#Case(g)\n",
+ "I_bL = (S_b3*1000)/V_b3 #Base current in load(A)\n",
+ "#Case(h)\n",
+ "I_L_pu = I_L/I_bL #Per unit load current\n",
+ "#Case(i)\n",
+ "V_R_pu = I_L_pu*Z_L_pu #Per unit voltage across load \n",
+ "#Case(j)\n",
+ "I_S_pu = I_L_pu #Per unit current of source\n",
+ "Z_T_pu = Z_L_pu+Z_1_pu+Z_2_pu #Total p.u impedance\n",
+ "V_S_pu = I_S_pu*Z_T_pu #Per unit voltage of source\n",
+ "V_S_pu_m = abs(V_S_pu) #Magnitude of V_S_pu\n",
+ "V_S_pu_a = cmath.phase(V_S_pu)*180/math.pi #Phase angle of V_S_pu(degrees)\n",
+ "#Case(k)\n",
+ "V_S = V_S_pu*V_b1 #Actual voltage across source(V)\n",
+ "V_S_m = abs(V_S) #Magnitude of V_S(V)\n",
+ "V_S_a = cmath.phase(V_S)*180/math.pi #Phase angle of V_S(degrees)\n",
+ "#Case(l)\n",
+ "I_x_pu = I_L_pu #p.u current at point x\n",
+ "Z_x_pu = Z_L_pu+Z_2_pu #p.u impedance at point x \n",
+ "V_x_pu = I_x_pu*Z_x_pu #p.u voltage at point x\n",
+ "#Case(m)\n",
+ "V_x = V_x_pu*V_b2 #Actual voltage at point x(V)\n",
+ "V_x_m = abs(V_x) #Magnitude of V_x(V)\n",
+ "V_x_a = cmath.phase(V_x)*180/math.pi #Phase angle of V_x(degrees)\n",
+ "\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Resistance of the load , R_L = %.f \u03a9' %R_L)\n",
+ "print('Case(b): Base impedance of the load , Z_bL = %.f \u03a9' %Z_bL)\n",
+ "print('Case(c): Per-unit load impedance , Z_L(pu) = (%.f+j%.f) p.u' %(Z_L_pu.real,Z_L_pu.imag))\n",
+ "print('Case(d): Per-unit impedance of transformer T2 , Z_2(pu) = j%.2f p.u' %Z_2_pu.imag)\n",
+ "print('Case(e): Per-unit impedance of transformer T1 , Z_1(pu) = j%.1f p.u' %Z_2_pu.imag)\n",
+ "print('Case(f): See Fig.14-23b in textbook page no-526')\n",
+ "print('Case(g): Base current in the load , I_bL = %.f A (resistive)' %I_bL)\n",
+ "print('Case(h): Per-unit load current , I_L_pu = (%.f+j%.f) p.u' %(I_L_pu.real,I_L_pu.imag))\n",
+ "print('Case(i): Per-unit voltage across load , V_R_pu = (%.f+j%.f) p.u' %(V_R_pu.real,V_R_pu.imag))\n",
+ "print('Case(j): Per-unit voltage of source , V_S_pu = %.3f\u2220%.2f\u00b0 pu' %(V_S_pu_m,V_S_pu_a))\n",
+ "print('Case(k): Actual voltage across source , V_S = %.1f\u2220%.2f\u00b0 pu' %(V_S_m,V_S_a))\n",
+ "print('Case(l): Per-unit voltage at point x in the second transmission loop , V_x(pu) = (%.f+j%.2f) p.u' %(V_x_pu.real,V_x_pu.imag))\n",
+ "print('Case(m): Voltage at point x , V_x = %.1f\u2220%.f\u00b0 V' %(V_x_m,V_x_a))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Resistance of the load , R_L = 1 \u03a9\n",
+ "Case(b): Base impedance of the load , Z_bL = 1 \u03a9\n",
+ "Case(c): Per-unit load impedance , Z_L(pu) = (1+j0) p.u\n",
+ "Case(d): Per-unit impedance of transformer T2 , Z_2(pu) = j0.25 p.u\n",
+ "Case(e): Per-unit impedance of transformer T1 , Z_1(pu) = j0.2 p.u\n",
+ "Case(f): See Fig.14-23b in textbook page no-526\n",
+ "Case(g): Base current in the load , I_bL = 120 A (resistive)\n",
+ "Case(h): Per-unit load current , I_L_pu = (1+j0) p.u\n",
+ "Case(i): Per-unit voltage across load , V_R_pu = (1+j0) p.u\n",
+ "Case(j): Per-unit voltage of source , V_S_pu = 1.097\u222024.23\u00b0 pu\n",
+ "Case(k): Actual voltage across source , V_S = 131.6\u222024.23\u00b0 pu\n",
+ "Case(l): Per-unit voltage at point x in the second transmission loop , V_x(pu) = (1+j0.25) p.u\n",
+ "Case(m): Voltage at point x , V_x = 618.5\u222014\u00b0 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.28, Page number 526"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_1 = 11.0 #Tr.1 voltage(kV)\n",
+ "V_b1 = 11.0 #Base Tr.1 voltage(kV)\n",
+ "S_1 = 50.0 #KVA rating of power for Tr.1\n",
+ "S_2 = 100.0 #KVA rating of power for Tr.2\n",
+ "Z_1_pu = complex(0,0.1) #Per unit impedance of Tr.1\n",
+ "Z_2_pu = complex(0,0.1) #Per unit impedance of Tr.2\n",
+ "V_b2 = 55.0 #Base Tr.2 voltage(kV)\n",
+ "S_b = 100.0 #Base power(kVA)\n",
+ "PF = 0.8 #Power factor of the load\n",
+ "Z_line = complex(0,200) #Line impedance(ohm)\n",
+ "V_L = 10.0 #Load voltage(kV)\n",
+ "V_Lb3 = 11.0 #Base line voltage at point 3(V)\n",
+ "V_b3 = 11.0 #Line voltage at point 3(V)\n",
+ "P_L = 50.0 #Power rating of each transformer(kW)\n",
+ "cos_theta_L = 0.8 #Lagging PF of load\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "Z_T1 = Z_1_pu*(V_1/V_b1)**2*(S_2/S_1) #p.u impedance of T1\n",
+ "#Case(b)\n",
+ "Z_T2 = Z_2_pu*(V_1/V_b3)**2*(S_2/S_1) #p.u impedance of T2\n",
+ "#Case(c)\n",
+ "V_b = V_b2 #Base voltage(V)\n",
+ "Z_b_line = (V_b**2)/S_b*1000 #Base line impedance(ohm)\n",
+ "Z_line_pu = Z_line/Z_b_line #p.u impedance of the transmission line\n",
+ "#Case(d)\n",
+ "V_L_pu = V_L/V_Lb3 #p.u voltage across load\n",
+ "#Case(f)\n",
+ "I_bL = S_b/V_b3 #Base current in load(A)\n",
+ "#Case(g)\n",
+ "VL = V_b3 #Load voltage(kV)\n",
+ "I_L = P_L/(VL*cos_theta_L) #Load current(A)\n",
+ "I_L_pu = I_L/I_bL #p.u load current\n",
+ "theta = math.acos(cos_theta_L) #PF angle(radian)\n",
+ "theta_a = theta*180/math.pi #PF angle(degree)\n",
+ "I_Lpu = I_L_pu*complex(math.cos(theta),-math.sin(theta)) #p.u current in complex form\n",
+ "#Case(h)\n",
+ "Z_series_pu = Z_T1+Z_line_pu+Z_T2 #p.u series impedance of the transmission line\n",
+ "V_S_pu = I_Lpu*Z_series_pu+V_L_pu #p.u source voltage\n",
+ "V_S_pu_m = abs(V_S_pu) #Magnitude of V_S_pu\n",
+ "V_S_pu_a = cmath.phase(V_S_pu)*180/math.pi #Phase angle of V_S_pu(degrees)\n",
+ "#Case(i)\n",
+ "V_S = V_S_pu*V_b1 #Actual value of source voltage(kV)\n",
+ "V_S_m = abs(V_S) #Magnitude of V_S_pu(kV)\n",
+ "V_S_a = cmath.phase(V_S)*180/math.pi #Phase angle of V_S(degrees)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Per-unit impedance of transformer T1 , Z_T1 = j%.1f p.u' %Z_T1.imag)\n",
+ "print('Case(b): Per-unit impedance of transformer T2 , Z_T2 = j%.1f p.u' %Z_T2.imag)\n",
+ "print('Case(c): Per-unit impedance of transmission line , Z(line)_pu = j%.4f p.u' %Z_line_pu.imag)\n",
+ "print('Case(d): Per-unit voltage across load , V_L_pu = (%.3f+j%.f) p.u' %(V_L_pu.real,V_L_pu.imag))\n",
+ "print('Case(e): See Fig.14-24b in textbook Page no-527')\n",
+ "print('Case(f): Base current in load , I_bL = %.3f A' %I_bL)\n",
+ "print('Case(g): Per-unit load current , I_L_pu = (%.1f%.3fj) p.u' %(I_Lpu.real,I_Lpu.imag))\n",
+ "print('Case(h): Per-unit source voltage , V_S_pu = %.3f\u2220%.2f\u00b0 pu' %(V_S_pu_m,V_S_pu_a))\n",
+ "print('Case(i): Actual value of source voltage , V_S = %.1f\u2220%.2f\u00b0 kV' %(V_S_m,V_S_a))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Per-unit impedance of transformer T1 , Z_T1 = j0.2 p.u\n",
+ "Case(b): Per-unit impedance of transformer T2 , Z_T2 = j0.2 p.u\n",
+ "Case(c): Per-unit impedance of transmission line , Z(line)_pu = j0.0066 p.u\n",
+ "Case(d): Per-unit voltage across load , V_L_pu = (0.909+j0) p.u\n",
+ "Case(e): See Fig.14-24b in textbook Page no-527\n",
+ "Case(f): Base current in load , I_bL = 9.091 A\n",
+ "Case(g): Per-unit load current , I_L_pu = (0.5-0.375j) p.u\n",
+ "Case(h): Per-unit source voltage , V_S_pu = 1.081\u222010.84\u00b0 pu\n",
+ "Case(i): Actual value of source voltage , V_S = 11.9\u222010.84\u00b0 kV\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.29, Page number 528"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "Z_pu_1 = 1j*0.1 #p.u impedance \n",
+ "MVA_2 = 80.0 #MVA rating os system 2\n",
+ "MVA_1 = 100.0 #MVA rating of T1 and T2\n",
+ "V_2 = 30.0 #Voltage(kV)\n",
+ "V_1 = 32.0 #Voltage(kV)\n",
+ "Z_pu_2 = 1j*0.15 #p.u impedance \n",
+ "V_b1 = 100.0 #Base voltage of T1(kV)\n",
+ "Z_line = 1j*60 #Line impedance(ohm)\n",
+ "MVA_M1 = 20.0 #MVA rating of motor load 1\n",
+ "Z_pu_M1 = 1j*0.15 #p.u impedance of motor load M1\n",
+ "MVA_M2 = 35.0 #MVA rating of motor load 2\n",
+ "Z_pu_M2 = 1j*0.25 #p.u impedance of motor load M2\n",
+ "MVA_M3 = 25.0 #MVA rating of motor load 3\n",
+ "Z_pu_M3 = 1j*0.2 #p.u impedance of motor load M3\n",
+ "V_M = 28.0 #Voltage across motor loads M1,M2,M3(kV)\n",
+ "\n",
+ "#Calculations\n",
+ "Z_1_pu = Z_pu_1*(MVA_2/MVA_1)*(V_2/V_1)**2 #p.u imepedance of T1\n",
+ "Z_2_pu = Z_pu_2*(MVA_2/MVA_1)*(V_2/V_1)**2 #p.u imepedance of T2\n",
+ "V_b_line = V_b1*(V_1/V_2) #ase voltage of the long-transmission line(kV)\n",
+ "MVA_b = 80.0 #Base MVA rating\n",
+ "V_b = V_b_line\n",
+ "Z_line_pu = Z_line*(MVA_b/(V_b_line)**2) #p.u impedance of the transmission line\n",
+ "Z_M1_pu = Z_pu_M1*(MVA_2/MVA_M1)*(V_M/V_1)**2 #p.u impedance of motor load M1\n",
+ "Z_M2_pu = Z_pu_M2*(MVA_2/MVA_M2)*(V_M/V_1)**2 #p.u impedance of motor load M2\n",
+ "Z_M3_pu = Z_pu_M3*(MVA_2/MVA_M3)*(V_M/V_1)**2 #p.u impedance of motor load M3\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Per-unit impedance of T1 , Z_1(pu) = j%.4f p.u' %Z_1_pu.imag)\n",
+ "print('Case(b): Per-unit impedance of T2 , Z_2(pu) = j%.4f p.u' %Z_2_pu.imag)\n",
+ "print('Case(c): Base voltage of the long-transmission line between T1 and T2 , V_b(line) = %.1f kV' %V_b_line)\n",
+ "print('Case(d): Per-unit impedance of the transmission line , Z(line)_pu = j%.4f p.u' %Z_line_pu.imag)\n",
+ "print('Case(e): Per-unit impedance of motor load M1 , Z_M1(pu) = j%.4f p.u' %Z_M1_pu.imag)\n",
+ "print('Case(f): Per-unit impedance of motor load M2 , Z_M2(pu) = j%.4f p.u' %Z_M2_pu.imag)\n",
+ "print('Case(g): Per-unit impedance of motor load M3 , Z_M3(pu) = j%.2f p.u' %Z_M3_pu.imag)\n",
+ "print('Case(h): See Fig.14-25b in textbook page no-529')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Per-unit impedance of T1 , Z_1(pu) = j0.0703 p.u\n",
+ "Case(b): Per-unit impedance of T2 , Z_2(pu) = j0.1055 p.u\n",
+ "Case(c): Base voltage of the long-transmission line between T1 and T2 , V_b(line) = 106.7 kV\n",
+ "Case(d): Per-unit impedance of the transmission line , Z(line)_pu = j0.4219 p.u\n",
+ "Case(e): Per-unit impedance of motor load M1 , Z_M1(pu) = j0.4594 p.u\n",
+ "Case(f): Per-unit impedance of motor load M2 , Z_M2(pu) = j0.4375 p.u\n",
+ "Case(g): Per-unit impedance of motor load M3 , Z_M3(pu) = j0.49 p.u\n",
+ "Case(h): See Fig.14-25b in textbook page no-529\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.30, Page number 533"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_pa = 1000.0 #Phase voltage(V)\n",
+ "I_1a = 1.0 #Line current in primary(A)\n",
+ "V_2a = 100.0 #Voltage across secondary(V)\n",
+ "Ic_a = 10.0 #Current in lower half of auto-transformer(A)\n",
+ "V_s = 100.0 #Voltage in secondary winding(V)\n",
+ "I_2b = 10.0 #Current in secondary(A)\n",
+ "V_1b = 1000.0 #Voltage across primary(V)\n",
+ "Ic_b = 1.0 #Current in lower half of auto-transformer(A)\n",
+ "\n",
+ "#Calculation\n",
+ "S_T1 = (V_pa*I_1a+V_2a*I_1a)/1000 #Total kVA transfer in step-down mode\n",
+ "S_T2 = (V_s*I_2b+V_1b*I_2b)/1000 #Total kVA transfer in step-up mode\n",
+ "S_x_former_c = V_pa*I_1a/1000 #kVA rating of th autotransformer in Fig.14-27a\n",
+ "V_1 = V_pa\n",
+ "S_x_former_d = V_1*Ic_b/1000 #kVA rating of th autotransformer in Fig.14-26b\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Total kVA transfer in step-down mode , S_T = %.1f kVA transferred' %S_T1)\n",
+ "print('Case(b): Total kVA transfer in step-up mode , S_T = %.1f kVA transferred' %S_T2)\n",
+ "print('Case(c): kVA rating of the autotransformer in Fig.14-27a , S_x-former = %.f kVA' %S_x_former_c)\n",
+ "print('Case(d): kVA rating of the autotransformer in Fig.14-26b , S_x-former = %.f kVA' %S_x_former_d)\n",
+ "print('Case(e): Both transformers have the same kVA rating of 1 kVA since the same autotransformer is used in both parts.')\n",
+ "print(' Both transformers transform a total of 1 KVA. But the step-down transformer in part(a) conducts only 0.1 kVA')\n",
+ "print(' while the step-up transformer in the part(b) conducts 10 kVA from the primary to the secondary')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Total kVA transfer in step-down mode , S_T = 1.1 kVA transferred\n",
+ "Case(b): Total kVA transfer in step-up mode , S_T = 11.0 kVA transferred\n",
+ "Case(c): kVA rating of the autotransformer in Fig.14-27a , S_x-former = 1 kVA\n",
+ "Case(d): kVA rating of the autotransformer in Fig.14-26b , S_x-former = 1 kVA\n",
+ "Case(e): Both transformers have the same kVA rating of 1 kVA since the same autotransformer is used in both parts.\n",
+ " Both transformers transform a total of 1 KVA. But the step-down transformer in part(a) conducts only 0.1 kVA\n",
+ " while the step-up transformer in the part(b) conducts 10 kVA from the primary to the secondary\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.31, Page number 535"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S = 500.0 #kVA rating of the distribution transformer\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 208.0 #Secondary voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "P_sc = 8200.0 #Wattmeter reading in SC test(W)\n",
+ "I_sc = 217.4 #Short circuit current(A)\n",
+ "V_sc = 95.0 #Short circuit voltage(V)\n",
+ "P_oc = 1800.0 #Wattmeter reading in OC test(W)\n",
+ "I_oc = 85.0 #Open circuit current(A)\n",
+ "V_oc = 208.0 #Open circuit voltage(V)\n",
+ "LF1 = 0.2 #Load fraction \n",
+ "LF2 = 0.4 #Load fraction \n",
+ "LF3 = 0.8 #Load fraction \n",
+ "LF4 = 1.25 #Load fraction \n",
+ "PF1 = 0.7 #Power factor\n",
+ "PF2 = 0.8 #Power factor\n",
+ "PF3 = 0.9 #Power factor\n",
+ "PF_fl = 1.0 #Power factor\n",
+ "PF4 = 0.85 #Power factor\n",
+ "t1 = 4.0 #Period of operation(hours)\n",
+ "t2 = 4.0 #Period of operation(hours)\n",
+ "t3 = 6.0 #Period of operation(hours)\n",
+ "t_fl = 6.0 #Period of operation(hours)\n",
+ "t4 = 2.0 #Period of operation(hours)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "t = 24.0 #Hours in a day\n",
+ "P_c = P_oc #Wattmeter reading(W). OC test\n",
+ "W_c = (P_c*t)/1000 #Core loss over 24 hour period(kWh)\n",
+ "#Case(b)\n",
+ "Psc = P_sc/1000 #Wattmeter reading(W). SC test\n",
+ "P_loss_1 = (LF1**2)*Psc #Power loss for 20% Load(kW)\n",
+ "P_loss_2 = (LF2**2)*Psc #Power loss for 40% Load(kW)\n",
+ "P_loss_3 = (LF3**2)*Psc #Power loss for 80% Load(kW)\n",
+ "P_loss_fl = Psc #Power loss for 100% Load(kW)\n",
+ "P_loss_4 = (LF4**2)*Psc #Power loss for 125% Load(kW)\n",
+ "energy_loss1 = P_loss_1*t1 #Enegry loss for 20% Load(kWh)\n",
+ "energy_loss2 = P_loss_2*t2 #Enegry loss for 40% Load(kWh)\n",
+ "energy_loss3 = P_loss_3*t3 #Enegry loss for 80% Load(kWh)\n",
+ "energy_loss_fl = P_loss_fl*t_fl #Enegry loss for 100% Load(kWh)\n",
+ "energy_loss4 = P_loss_4*t4 #Enegry loss for 125% Load(kWh)\n",
+ "W_loss_total = energy_loss1+energy_loss2+energy_loss3+energy_loss_fl+energy_loss4 #Total energy loss(kWh)\n",
+ "#Case(c)\n",
+ "P_1 = LF1*S*PF1 #Power output for 20% load(kW)\n",
+ "P_2 = LF2*S*PF2 #Power output for 40% load(kW)\n",
+ "P_3 = LF3*S*PF3 #Power output for 80% load(kW)\n",
+ "P_fl = S*PF_fl #Power output for 100% load(kW)\n",
+ "P_4 = LF4*S*PF4 #Power output for 125% load(kW)\n",
+ "Energy_1 = P_1*t1 #Energy delivered for 20% load(kWh)\n",
+ "Energy_2 = P_2*t2 #Energy delivered for 40% load(kWh)\n",
+ "Energy_3 = P_3*t3 #Energy delivered for 80% load(kWh)\n",
+ "Energy_fl = P_fl*t_fl #Energy delivered for 100% load(kWh)\n",
+ "Energy_4 = P_4*t4 #Energy delivered for 125% load(kWh)\n",
+ "W_out_total = Energy_1+Energy_2+Energy_3+Energy_fl+Energy_4 #Total energy delivered in 24hrs(kwh)\n",
+ "#Case(d)\n",
+ "n = W_out_total/(W_out_total+W_c+W_loss_total)*100 #All-day efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('case(a): Core loss over the 24 hour period , W_c = P_c*t = %.1f kWh' %W_c)\n",
+ "print('Case(b): Total energy loss over the 24 hour period = %.2f kWh' %W_loss_total)\n",
+ "print('Case(c): Total energy output over the 24 hour period = %.f kWh' %W_out_total)\n",
+ "print('Case(d): All-day efficiency = %.1f percent' %n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "case(a): Core loss over the 24 hour period , W_c = P_c*t = 43.2 kWh\n",
+ "Case(b): Total energy loss over the 24 hour period = 112.87 kWh\n",
+ "Case(c): Total energy output over the 24 hour period = 7142 kWh\n",
+ "Case(d): All-day efficiency = 97.9 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.32, Page number 540"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S_1 = 10.0 #VA rating of small transformer\n",
+ "V = 115.0 #Voltage rating of transformer(V)\n",
+ "V_2_1 = 6.3 #Voltage rating of one part of secondary winding(V)\n",
+ "V_2_2 = 5.0 #Voltage rating of other part of secondary winding(V)\n",
+ "Z_2_1 = 0.2 #Impedance of one part of secondary winding(ohm)\n",
+ "Z_2_2 = 0.15 #Impedance of other part of secondary winding(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_2 = V_2_1+V_2_2 #Voltage across secondary winding(V)\n",
+ "I_2 = S_1/V_2 #Rated secondary current when the LV secondaries are connected in series-aiding(A)\n",
+ "#Case(b)\n",
+ "I_c = (V_2_1-V_2_2)/(Z_2_1+Z_2_2) #Circulating current when LV windings are paralled(A)\n",
+ "percent_overload = (I_c/I_2)*100 #Percent overload produced\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rated secondary current when the low-voltage secondaries are connected series-aiding , I_2 = %.3f A' %I_2)\n",
+ "print('Case(b): Circulating current when LV windings are paralled , I_c = %.2f A' %I_c)\n",
+ "print(' Percent overload produced = %.f percent' %percent_overload)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rated secondary current when the low-voltage secondaries are connected series-aiding , I_2 = 0.885 A\n",
+ "Case(b): Circulating current when LV windings are paralled , I_c = 3.71 A\n",
+ " Percent overload produced = 420 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.33, Page number 541"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S = 20.0 #kVA rating of transformer\n",
+ "N_1 = 230.0 #Number of primary turns\n",
+ "N_2 = 20.0 #Number of secondary turns\n",
+ "V_1 = 230.0 #Primary voltage(V)\n",
+ "V_2 = 20.0 #Secondary voltage(V)\n",
+ "V_sc = 4.5 #Short circuit voltage(V)\n",
+ "I_sc = 87.0 #Short circuit current(A)\n",
+ "P_sc = 250.0 #Power measured(W)\n",
+ "\n",
+ "#Calculation\n",
+ "V_h = V_sc #Short circuit voltage on HV side(V)\n",
+ "I_h = I_sc #Short circuit current on HV side(A)\n",
+ "Z_eh = V_h/I_h #Equivalent impedance reffered to the high side when coils are series connected(ohm)\n",
+ "Z_el = Z_eh*(N_2/N_1)**2 #Equivalent impedance reffered to the low side when coils are series connected(ohm)\n",
+ "I_2_rated = (S*1000)/V_2 #Rated secondary current when coils are series connected(A)\n",
+ "I_2_sc = S/Z_el #Secondary current when coils in Fig.14-31a are short-circuited with rated voltage applied to HV side(A)\n",
+ "percent_overload = (I_2_sc/I_2_rated)*100 #Percent overload\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent impedance reffered to the high side when coils are series-connected , Z_eh = %.4f ohm' %Z_eh)\n",
+ "print('Case(b): Equivalent impedance reffered to the low side when coils are series connected , Z_el = %.2e ohm' %Z_el)\n",
+ "print('Case(c): Rated secondary current when coils are series connected , I_2(rated) = %.e A' %I_2_rated)\n",
+ "print('Case(d): Secondary current when coils in Fig.14-31a are short-circuited with rated voltage applied to HV side , I_2(sc) = %.1e A' %I_2_sc)\n",
+ "print(' Percent overload produced = %.f percent' %percent_overload)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent impedance reffered to the high side when coils are series-connected , Z_eh = 0.0517 ohm\n",
+ "Case(b): Equivalent impedance reffered to the low side when coils are series connected , Z_el = 3.91e-04 ohm\n",
+ "Case(c): Rated secondary current when coils are series connected , I_2(rated) = 1e+03 A\n",
+ "Case(d): Secondary current when coils in Fig.14-31a are short-circuited with rated voltage applied to HV side , I_2(sc) = 5.1e+04 A\n",
+ " Percent overload produced = 5114 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.34, Page number 548"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "I_L = 100.0 #Load current(A)\n",
+ "cos_theta = 0.7 #Power factor lagging\n",
+ "S = 60.0 #kVA rating of transformer\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_L = 230.0 #Voltage across load(V)\n",
+ "P_T = (3**0.5*V_L*I_L*cos_theta)/1000 #Power consumed by the plant(kW)\n",
+ "kVA_T = P_T/cos_theta #Apparent power(kVA)\n",
+ "#Case(b)\n",
+ "kVA = S #kVA rating of transformer\n",
+ "V_p = V_2 #Phase voltage(V). delta-connection on load side\n",
+ "I_P2_rated = (kVA*1000)/(3*V_p) #Rated secondary phase current(A)\n",
+ "I_L2_rated = 3**0.5*I_P2_rated #Rated secondary line current(A)\n",
+ "#Case(c)\n",
+ "percent_load = I_L/I_L2_rated*100 #Percent load on each transformer \n",
+ "#Case(d)\n",
+ "V_L_d = 2300.0\n",
+ "I_P1 = (kVA_T*1000)/(3**0.5*V_L_d) #Primary phase current(A)\n",
+ "I_L1 = I_P1 #Primary line current(A). Y-connection\n",
+ "#Case(e)\n",
+ "kVA_transformer = kVA/3 #kVA rating of each transformer\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Power consumed by the plant , P_T = %.1f kW' %P_T)\n",
+ "print(' Apparent power , kVA_T = %.1f kVA' %kVA_T)\n",
+ "print('Case(b): Rated secondary phase current of transformer bank , I_P2(rated) = %.f A' %I_P2_rated)\n",
+ "print(' Rated secondary line current of transformer bank , I_L2(rated) = %.1f A' %I_L2_rated)\n",
+ "print('Case(c): Percent load on each transformer = %.1f percent' %percent_load)\n",
+ "print('Case(d): Primary phase current drawn by each transformer , I_P1 = %.f A' %I_P1)\n",
+ "print(' Primary line current drawn by each transformer , I_L1 = %.f A' %I_L1)\n",
+ "print('Case(e): kVA rating of each transformer = %.f kVA' %kVA_transformer)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Power consumed by the plant , P_T = 27.9 kW\n",
+ " Apparent power , kVA_T = 39.8 kVA\n",
+ "Case(b): Rated secondary phase current of transformer bank , I_P2(rated) = 87 A\n",
+ " Rated secondary line current of transformer bank , I_L2(rated) = 150.6 A\n",
+ "Case(c): Percent load on each transformer = 66.4 percent\n",
+ "Case(d): Primary phase current drawn by each transformer , I_P1 = 10 A\n",
+ " Primary line current drawn by each transformer , I_L1 = 10 A\n",
+ "Case(e): kVA rating of each transformer = 20 kVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.35, Page number 548"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "I_L = 100.0 #Load current(A)\n",
+ "cos_theta = 0.7 #Power factor lagging\n",
+ "S = 60.0 #kVA rating of transformer\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_L = 230.0 #Voltage across load(V)\n",
+ "P_T = (3**0.5*V_L*I_L*cos_theta)/1000 #Power consumed by the plant(kW)\n",
+ "kVA_T = P_T/cos_theta #Apparent power(kVA)\n",
+ "#Case(b)\n",
+ "kVA = S #kVA rating of transformer\n",
+ "V_p = V_2 #Phase voltage(V)\n",
+ "I_P2_rated = (kVA*1000)/(3*V_p) #Rated secondary phase current(A)\n",
+ "I_L2_rated = 3**0.5*I_P2_rated #Rated secondary line current(A)\n",
+ "#Case(c)\n",
+ "percent_load = I_L/I_L2_rated*100 #Percent load on each transformer \n",
+ "#Case(d)\n",
+ "V_L_d = 2300.0\n",
+ "I_P1 = (kVA_T*1000)/(3**0.5*V_L_d) #Primary phase current(A)\n",
+ "I_L1 = 3**0.5*I_P1 #Primary line current(A)\n",
+ "#Case(e)\n",
+ "kVA_transformer = kVA/3 #kVA rating of each transformer\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Power consumed by the plant , P_T = %.1f kW' %P_T)\n",
+ "print(' Apparent power , kVA_T = %.1f kVA' %kVA_T)\n",
+ "print('Case(b): Rated secondary phase current of transformer bank , I_P2(rated) = %.f A' %I_P2_rated)\n",
+ "print(' Rated secondary line current of transformer bank , I_L2(rated) = %.1f A' %I_L2_rated)\n",
+ "print('Case(c): Percent load on each transformer = %.1f percent' %percent_load)\n",
+ "print('Case(d): Primary phase current drawn by each transformer , I_P1 = %.f A' %I_P1)\n",
+ "print(' Primary line current drawn by each transformer , I_L1 = %.1f A' %I_L1)\n",
+ "print(' Primary line current drawn by a \u0394-\u0394 bank is \u221a3 times the line current drawn by a Y-\u0394 bank')\n",
+ "print('Case(e): kVA rating of each transformer = %.f kVA' %kVA_transformer)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Power consumed by the plant , P_T = 27.9 kW\n",
+ " Apparent power , kVA_T = 39.8 kVA\n",
+ "Case(b): Rated secondary phase current of transformer bank , I_P2(rated) = 87 A\n",
+ " Rated secondary line current of transformer bank , I_L2(rated) = 150.6 A\n",
+ "Case(c): Percent load on each transformer = 66.4 percent\n",
+ "Case(d): Primary phase current drawn by each transformer , I_P1 = 10 A\n",
+ " Primary line current drawn by each transformer , I_L1 = 17.3 A\n",
+ " Primary line current drawn by a \u0394-\u0394 bank is \u221a3 times the line current drawn by a Y-\u0394 bank\n",
+ "Case(e): kVA rating of each transformer = 20 kVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.36, Page number 554"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_L = 33.0 #Line voltage(kV)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "PF1 = 1.0 #Unity power factor for I_AB\n",
+ "PF2 = 0.7 #Lagging power factor for I_BC\n",
+ "PF3 = 0.9 #Leading power factor for I_CA\n",
+ "IAB = 10.0 #Magnitude of I_AB(kA)\n",
+ "IBC = 15.0 #Magnitude of I_BC(kA)\n",
+ "ICA = 12.0 #Magnitude of I_CA(kA)\n",
+ "\n",
+ "#Calculation\n",
+ "V_AB = V_L*cmath.exp(1j*0*math.pi/180) #Line voltage taken as reference voltage(kV)\n",
+ "V_AB_a = cmath.phase(V_AB)*180/math.pi #Voltage angle(degree)\n",
+ "V_BC = V_L*cmath.exp(1j*-120*math.pi/180) #Line voltage(kV)\n",
+ "V_BC_a = cmath.phase(V_BC)*180/math.pi #Voltage angle(degree)\n",
+ "V_CA = V_L*cmath.exp(1j*120*math.pi/180) #Line voltage(kV)\n",
+ "V_CA_a = cmath.phase(V_CA)*180/math.pi #Voltage angle(degree)\n",
+ "theta_1 = math.acos(PF1)*180/math.pi #PF1 angle(degree)\n",
+ "theta_2 = math.acos(PF2)*180/math.pi #PF2 angle(degree)\n",
+ "theta_3 = math.acos(PF3)*180/math.pi #PF3 angle(degree)\n",
+ "I_AB = IAB*cmath.exp(1j*(theta_1)*math.pi/180) #Current(kA)\n",
+ "I_BC = IBC*cmath.exp(1j*(V_BC_a-theta_2)*math.pi/180) #Current(kA)\n",
+ "I_CA = ICA*cmath.exp(1j*(V_CA_a+theta_3)*math.pi/180) #Current(kA)\n",
+ "#Case(a)\n",
+ "I_AC = -I_CA\n",
+ "I_A = I_AB+I_AC #Phase current(kA)\n",
+ "I_A_m = abs(I_A) #Magnitude of I_A(kA)\n",
+ "I_A_a = cmath.phase(I_A)*180/math.pi #Phase angle of I_A(degrees)\n",
+ "#Case(b)\n",
+ "I_BA = -I_AB\n",
+ "I_B = I_BC+I_BA #Phase current(kA)\n",
+ "I_B_m = abs(I_B) #Magnitude of I_B(kA)\n",
+ "I_B_a = cmath.phase(I_B)*180/math.pi #Phase angle of I_B(degrees)\n",
+ "#Case(c)\n",
+ "I_CB = -I_BC\n",
+ "I_C = I_CA+I_CB #Phase current(kA)\n",
+ "I_C_m = abs(I_C) #Magnitude of I_C(kA)\n",
+ "I_C_a = cmath.phase(I_C)*180/math.pi #Phase angle of I_C(degrees)\n",
+ "#Case(d)\n",
+ "phasor_sum = I_A+I_B+I_C #Phasor sum of line currents\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Current in line A , I_A = %.2f\u2220%.2f\u00b0 kA' %(I_A_m,I_A_a))\n",
+ "print('Case(b): Current in line B , I_B = %.2f\u2220%.2f\u00b0 kA' %(I_B_m,I_B_a))\n",
+ "print('Case(c): Current in line C , I_C = %.2f\u2220%.2f\u00b0 kA' %(I_C_m,I_C_a))\n",
+ "print('Case(d): Phasor sum of line currents , \u03a3I_L = (%.f+j%.f) ' %(phasor_sum.real,phasor_sum.imag))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Current in line A , I_A = 21.04\u2220-18.68\u00b0 kA\n",
+ "Case(b): Current in line B , I_B = 24.81\u2220-171.34\u00b0 kA\n",
+ "Case(c): Current in line C , I_C = 11.44\u222066.30\u00b0 kA\n",
+ "Case(d): Phasor sum of line currents , \u03a3I_L = (-0+j0) \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.37, Page number 556"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA_1 = 20.0 #kVA rating of transformer 1\n",
+ "kVA_2 = 20.0 #kVA rating of transformer 2\n",
+ "kVA_3 = 20.0 #kVA rating of transformer 3\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "kVA = 40.0 #kVA supplied by the bank\n",
+ "PF = 0.7 #Lagging power factor at which bank supplies kVA\n",
+ "\n",
+ "#Calculation\n",
+ "kVA_transformer = kVA/3**0.5 #kVA load carried by each transformer\n",
+ "percent_ratedload_Tr = kVA_transformer/kVA_1*100 #Percent load carried by each transformer\n",
+ "kVA_V_V = 3**0.5*kVA_1 #Total kVA rating of the transformer bank in V-V\n",
+ "ratio_banks = kVA_V_V/(kVA_1+kVA_2+kVA_3)*100 #Ratio of V-V bank to \u0394-\u0394 bank transformer ratings\n",
+ "kVA_Tr = kVA/3 \n",
+ "percent_increase_load = kVA_transformer/kVA_Tr*100 #Percent increase in load on each transformer when one transformer is removed\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): kVA load carried by each transformer = %.1f kVA/transformer' %kVA_transformer)\n",
+ "print('Case(b): Percent rated load carried by each transformer = %.1f percent' %percent_ratedload_Tr)\n",
+ "print('Case(c): Total kVA rating of the transformer bank in V-V = %.2f kVA' %kVA_V_V)\n",
+ "print('Case(d): Ratio of V-V bank to \u0394-\u0394 bank transformer ratings = %.1f percent' %ratio_banks)\n",
+ "print('Case(e): Percent increase in load on each transformer when one transformer is removed = %.1f percent' %percent_increase_load)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): kVA load carried by each transformer = 23.1 kVA/transformer\n",
+ "Case(b): Percent rated load carried by each transformer = 115.5 percent\n",
+ "Case(c): Total kVA rating of the transformer bank in V-V = 34.64 kVA\n",
+ "Case(d): Ratio of V-V bank to \u0394-\u0394 bank transformer ratings = 57.7 percent\n",
+ "Case(e): Percent increase in load on each transformer when one transformer is removed = 173.2 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.38, Page number 562"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 440.0 #Rated voltage of SCIM(V)\n",
+ "hp = 100.0 #Rated power of SCIM(hp)\n",
+ "PF = 0.8 #Power factor\n",
+ "V_1 = 155.0 #Primary voltage of transformer(V)\n",
+ "V_2 = 110.0 #Secondary voltage of transformer(V)\n",
+ "V_a = 110.0 #Armature voltage(V)\n",
+ "V_L = 440.0 #Load voltage(V)\n",
+ "n = 0.98 #Efficiency of the transformer\n",
+ "\n",
+ "#Calculation\n",
+ "I_L = 124*1.25 #Motor line current(A). Appendix A-3\n",
+ "alpha = V_a/V_L #Transformation ratio\n",
+ "I_a = (3**0.5/2)*(I_L/(alpha*n)) #Current in the primary of the scott transformers(A)\n",
+ "kVA = (V_a*I_a)/((3**0.5/2)*1000) #kVA rating of the main and teaser transformers\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Motor line current , I_L = %.f A' %I_L)\n",
+ "print('Case(b): Transformation ratio , \u03b1 = N_1/N_2 = V_a/V_L = %.2f ' %alpha)\n",
+ "print('Case(c): Current in the primary of the scott transformers , I_a = %.f A' %I_a)\n",
+ "print('Case(d): kVA rating of the main and teaser transformers , kVA = %.1f kVA' %kVA)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Motor line current , I_L = 155 A\n",
+ "Case(b): Transformation ratio , \u03b1 = N_1/N_2 = V_a/V_L = 0.25 \n",
+ "Case(c): Current in the primary of the scott transformers , I_a = 548 A\n",
+ "Case(d): kVA rating of the main and teaser transformers , kVA = 69.6 kVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.39, Page number 570"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "I_L = 1.0 #Load current(kA)\n",
+ "V_m = 750.0 #Peak voltage(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "V_L = (V_m)/2**0.5 #Maximum allowable rms voltagethat may be applied to the lines using ac(kV)\n",
+ "S_T_ac = 3**0.5*V_L*I_L #Total 3-phase apparent power(MVA)\n",
+ "I_rms = I_L #rms value of load current(kA)\n",
+ "I_dc =I_rms*2**0.5 #Maximum allowable current that can be delivered by dc transmission(kA)\n",
+ "V_dc = V_m #dc voltage(kV)\n",
+ "S_T_dc = V_dc*I_dc #Total dc apparent power delivered by two lines(MVA)\n",
+ "S_ac_line = S_T_ac/3 #Power per ac line\n",
+ "S_dc_line = S_T_dc/2 #Power per dc line\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Maximum allowable rms voltage that may be applied to the lines using ac , V_L = %.1f kV' %V_L)\n",
+ "print('Case(b): Total 3-phase ac apparent power delivered by three lines , S_T = %.1f MVA' %S_T_ac)\n",
+ "print('Case(c): Maximum allowable current that can be delivered by dc transmission , I_dc = %.3f kA' %I_dc)\n",
+ "print('Case(d): Total dc apparent power delivered by two lines , S_T = %.1f MVA' %S_T_dc)\n",
+ "print('Case(e): Power per ac line , S/ac line = %.1f MVA/line' %S_ac_line)\n",
+ "print('Case(f): Power per dc line , S/dc line = %.1f MVA/line' %S_dc_line)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Maximum allowable rms voltage that may be applied to the lines using ac , V_L = 530.3 kV\n",
+ "Case(b): Total 3-phase ac apparent power delivered by three lines , S_T = 918.6 MVA\n",
+ "Case(c): Maximum allowable current that can be delivered by dc transmission , I_dc = 1.414 kA\n",
+ "Case(d): Total dc apparent power delivered by two lines , S_T = 1060.7 MVA\n",
+ "Case(e): Power per ac line , S/ac line = 306.2 MVA/line\n",
+ "Case(f): Power per dc line , S/dc line = 530.3 MVA/line\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_2.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_2.ipynb new file mode 100755 index 00000000..1e18289c --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_2.ipynb @@ -0,0 +1,432 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 2: DYNAMO CONSTRUCTION AND WINDINGS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.1, Page number 48"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "m = 3.0 #Multipicity of the armature\n",
+ "P = 14.0 #Number of poles\n",
+ "\n",
+ "#Calculation\n",
+ "a_lap = m*P #Number of paths in the armature for lap winding\n",
+ "a_wave = 2*m #Number of paths in the armature for wave winding\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Number of paths in the armature for lap winding , a = %.f paths' %a_lap)\n",
+ "print('Case(b): Number of paths in the armature for wave winding , a = %.f paths' %a_wave)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Number of paths in the armature for lap winding , a = 42 paths\n",
+ "Case(b): Number of paths in the armature for wave winding , a = 6 paths\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.2, Page number 48"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 14.0 #Number of poles\n",
+ "phi = 4.2*10**6 #Flux per pole(lines)\n",
+ "S = 60.0 #Generator speed(rpm)\n",
+ "coils = 420.0 #Number of coils\n",
+ "turns_per_coil = 20.0 #Turns per coil\n",
+ "conductors_per_turn = 2.0 #Conductors per turn \n",
+ "a_lap = 42.0 #Number of parallel paths in the armature for a lap winding\n",
+ "a_wave = 6.0 #Number of parallel paths in the armature for a wave winding\n",
+ "\n",
+ "#Calculation\n",
+ "Z = coils*turns_per_coil*conductors_per_turn #Number of conductors\n",
+ "E_g_lap = phi*Z*S*P/(60*a_lap)*10**-8 #Generated EMF for lap winding(V)\n",
+ "E_g_wave = phi*Z*S*P/(60*a_wave)*10**-8 #Generated EMF for wave winding(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Generated EMF for lap winding , E_g = %.1f V' %E_g_lap)\n",
+ "print('Case(b): Generated EMF for wave winding , E_g = %.1f V' %E_g_wave)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Generated EMF for lap winding , E_g = 235.2 V\n",
+ "Case(b): Generated EMF for wave winding , E_g = 1646.4 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.3, Page number 53"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "slots = 72.0 #Number of slots\n",
+ "P = 4.0 #Number of poles\n",
+ "coils_spanned = 14.0 #14 slots are spanned while winding the coils\n",
+ "\n",
+ "#Calculation\n",
+ "coil_span = slots/P #Full-pitch coil span(slots/pole)\n",
+ "p_degree = coils_spanned/coil_span*180 #Span of the coil in electrical degrees\n",
+ "beta = (180-p_degree) #Beta(degree)\n",
+ "k_p1 = math.cos(beta/2*(math.pi/180)) #Pitch factor using eq(2-7)\n",
+ "k_p2 = math.sin(p_degree/2*(math.pi/180)) #Pitch factor using eq(2-8)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full-pitch coil span = %.f slots/pole' %coil_span)\n",
+ "print('Case(b): Span of the coil in electrical degrees , p\u00b0 = %.f\u00b0' %p_degree)\n",
+ "print('Case(c): Pitch factor , k_p = %.2f ' %k_p1)\n",
+ "print('Case(d): Pitch factor , k_p = %.2f ' %k_p2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full-pitch coil span = 18 slots/pole\n",
+ "Case(b): Span of the coil in electrical degrees , p\u00b0 = 140\u00b0\n",
+ "Case(c): Pitch factor , k_p = 0.94 \n",
+ "Case(d): Pitch factor , k_p = 0.94 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.4, Page number 54"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "fractional_pitch = 13.0/16 #Coils having fractional pitch\n",
+ "slot =96.0 #Number of slots\n",
+ "P = 6.0 #Number of poles\n",
+ "\n",
+ "#Calculation\n",
+ "p_degree = fractional_pitch*180 #Span of the coil in electrical degrees\n",
+ "k_p = math.sin(p_degree/2*(math.pi/180)) #Pitch factor\n",
+ "\n",
+ "#Result\n",
+ "print('Pitch factor , k_p = %.4f ' %k_p)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Pitch factor , k_p = 0.9569 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.5, Page number 54"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 12.0 #Number of poles\n",
+ "theta = 360.0 #Number of mechanical degrees of rotation\n",
+ "alpha_b = 180.0 #Number of electrical degrees in case(b)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = (P*theta)/2 #Number of electrical degrees in one revolution(degree)\n",
+ "n = alpha/360 #Number of ac cycles\n",
+ "theta_b = (2*alpha_b)/P #Number of mechanical degrees of rotation\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Number of electrical degrees in one revolution , \u03b1 = %.f\u00b0 ' %alpha)\n",
+ "print(' Number of ac cycles , n = %.f cycles' %n)\n",
+ "print('Case(b): Mechanical angle , \u03b8 = %.f mechanical degrees' %theta_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Number of electrical degrees in one revolution , \u03b1 = 2160\u00b0 \n",
+ " Number of ac cycles , n = 6 cycles\n",
+ "Case(b): Mechanical angle , \u03b8 = 30 mechanical degrees\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.6, Page number 56"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 4.0 #Number of poles\n",
+ "phi = 3.0 #Number of phases\n",
+ "slot_1 = 12.0 #Number of slots for case 1\n",
+ "slot_2 = 24.0 #Number of slots for case 2\n",
+ "slot_3 = 48.0 #Number of slots for case 3\n",
+ "slot_4 = 84.0 #Number of slots for case 4\n",
+ "\n",
+ "#Calculation\n",
+ "electrical_degrees = 180.0*P #Electrical degrees\n",
+ "#Case(a)\n",
+ "alpha_1 = electrical_degrees/slot_1 #Number of electrical degrees(\u00b0/slot)\n",
+ "n_1 = slot_1/(P*phi) #Number of slots per pole per phase(slot/pole-phase)\n",
+ "k_d1 = math.sin(n_1*alpha_1/2*(math.pi/180))/(n_1*math.sin(alpha_1/2*(math.pi/180)))#Distribution factor\n",
+ "#Case(b)\n",
+ "alpha_2 = electrical_degrees/slot_2 #Number of electrical degrees(\u00b0/slot)\n",
+ "n_2 = slot_2/(P*phi) #Number of slots per pole per phase(slot/pole-phase)\n",
+ "k_d2 = math.sin(n_2*alpha_2/2*(math.pi/180))/(n_2*math.sin(alpha_2/2*(math.pi/180)))#Distribution factor\n",
+ "#Case(c)\n",
+ "alpha_3 = electrical_degrees/slot_3 #Number of electrical degrees(\u00b0/slot)\n",
+ "n_3 = slot_3/(P*phi) #Number of slots per pole per phase(slot/pole-phase)\n",
+ "k_d3 = math.sin(n_3*alpha_3/2*(math.pi/180))/(n_3*math.sin(alpha_3/2*(math.pi/180)))#Distribution factor\n",
+ "#Case(d)\n",
+ "alpha_4 = electrical_degrees/slot_4 #Number of electrical degrees(\u00b0/slot)\n",
+ "n_4 = slot_4/(P*phi) #Number of slots per pole per phase(slot/pole-phase)\n",
+ "k_d4 = math.sin(n_4*alpha_4/2*(math.pi/180))/(n_4*math.sin(alpha_4/2*(math.pi/180)))#Distribution factor\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Distribution factor , k_d')\n",
+ "print(' 1: k_d = %.1f ' %k_d1)\n",
+ "print(' 2: k_d = %.3f ' %k_d2)\n",
+ "print(' 3: k_d = %.3f ' %k_d3)\n",
+ "print(' 4: k_d = %.3f ' %k_d4)\n",
+ "print('\\nCase(b): Tabular column')\n",
+ "print(' ________________________')\n",
+ "print(' n \\t \u03b1 \\t k_d')\n",
+ "print(' ________________________')\n",
+ "print(' %d \\t %d\u00b0 \\t %.1f' %(n_1,alpha_1,k_d1))\n",
+ "print(' %d \\t %d\u00b0 \\t %.3f' %(n_2,alpha_2,k_d2))\n",
+ "print(' %d \\t %d\u00b0 \\t %.3f' %(n_3,alpha_3,k_d3))\n",
+ "print(' %d \\t %.2f\u00b0 \\t %.3f' %(n_4,alpha_4,k_d4))\n",
+ "print(' ________________________')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Distribution factor , k_d\n",
+ " 1: k_d = 1.0 \n",
+ " 2: k_d = 0.966 \n",
+ " 3: k_d = 0.958 \n",
+ " 4: k_d = 0.956 \n",
+ "\n",
+ "Case(b): Tabular column\n",
+ " ________________________\n",
+ " n \t \u03b1 \t k_d\n",
+ " ________________________\n",
+ " 1 \t 60\u00b0 \t 1.0\n",
+ " 2 \t 30\u00b0 \t 0.966\n",
+ " 4 \t 15\u00b0 \t 0.958\n",
+ " 7 \t 8.57\u00b0 \t 0.956\n",
+ " ________________________\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.7, Page number 56"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "slots = 72.0 #Number of slots\n",
+ "P = 6.0 #Number of poles\n",
+ "phase = 3.0 #Three phase stator armature\n",
+ "N_c = 20.0 #Number of turns per coil\n",
+ "pitch = 5.0/6 #Pitch\n",
+ "phi = 4.8*10**6 #Flux per pole(lines)\n",
+ "S = 1200.0 #Rotor speed(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "f = (P*S)/120 #Frequency of rotor(Hz)\n",
+ "E_g_percoil = 4.44*phi*N_c*f*10**-8 #Generated effective voltage per coil of a full pitch coil(V/coil)\n",
+ "#Case(b)\n",
+ "N_p = (slots/phase)*N_c #Total number of turns per phase(turns/phase)\n",
+ "#Case(c)\n",
+ "n = slots/(phase*P) #Number of slots per pole per phase(slots/pole-phase)\n",
+ "alpha = (P*180)/slots #Number of electrical degrees between adjacent slots(degree)\n",
+ "k_d = math.sin(n*alpha/2*(math.pi/180))/(n*math.sin(alpha/2*(math.pi/180))) #Distribution factor\n",
+ "#Case(d)\n",
+ "span = pitch*180 #Span of the coil in electrical degrees\n",
+ "k_p = math.sin(span/2*(math.pi/180)) #Pitch factor\n",
+ "#Case(e)\n",
+ "E_gp = 4.44*phi*N_p*f*k_p*k_d*10**-8 #Total generated voltage(V/phase)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Generated effective voltage per coil of a full-pitch coil , E_g/coil = %.f V/coil' %E_g_percoil)\n",
+ "print('Case(b): Total number of turns per phase , N_p = %.f turns/phase' %N_p)\n",
+ "print('Case(c): Distribution factor , k_d = %.3f ' %k_d)\n",
+ "print('Case(d): Pitch factor , k_p = %.3f ' %k_p)\n",
+ "print('Case(e): Total generated voltage per phase , E_gp = %.f V/phase' %E_gp)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Generated effective voltage per coil of a full-pitch coil , E_g/coil = 256 V/coil\n",
+ "Case(b): Total number of turns per phase , N_p = 480 turns/phase\n",
+ "Case(c): Distribution factor , k_d = 0.958 \n",
+ "Case(d): Pitch factor , k_p = 0.966 \n",
+ "Case(e): Total generated voltage per phase , E_gp = 5678 V/phase\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.8, Page number 62"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 8.0 #Number of poles\n",
+ "S = 900.0 #Speed(rev/min)\n",
+ "f_1 = 50.0 #Frequency(Hz)\n",
+ "f_2 = 25.0 #Frequency(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "f = (P*S)/120 #Frequency of the generated voltage(Hz)\n",
+ "S_1 = (120*f_1)/P #Speed of prime mover to generate 50 Hz(rpm)\n",
+ "S_2 = (120*f_2)/P #Speed of prime mover to generate 25 Hz(rpm)\n",
+ "omega_1 = (4*math.pi*f_1)/P #Speed of prime mover to generate 50 Hz(rad/s)\n",
+ "omega_2 = (4*math.pi*f_2)/P #Speed of prime mover to generate 25 Hz(rad/s)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Frequency of the generated voltage , f = %.f Hz' %f)\n",
+ "print('Case(b): Prime mover speed required to generate 50 Hz , S = %.f rpm' %S_1)\n",
+ "print(' Prime mover speed required to generate 25 Hz , S = %.f rpm' %S_2)\n",
+ "print('Case(c): Prime mover speed required to generate 50 Hz , S = %.f\u03c0 rad/s' %(omega_1/math.pi))\n",
+ "print(' Prime mover speed required to generate 25 Hz , S = %.1f\u03c0 rad/s' %(omega_2/math.pi))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Frequency of the generated voltage , f = 60 Hz\n",
+ "Case(b): Prime mover speed required to generate 50 Hz , S = 750 rpm\n",
+ " Prime mover speed required to generate 25 Hz , S = 375 rpm\n",
+ "Case(c): Prime mover speed required to generate 50 Hz , S = 25\u03c0 rad/s\n",
+ " Prime mover speed required to generate 25 Hz , S = 12.5\u03c0 rad/s\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_3.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_3.ipynb new file mode 100755 index 00000000..b3e30a75 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_3.ipynb @@ -0,0 +1,451 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 3: DC DYNAMO VOLTAGE RELATIONS-DC GENERATORS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.1, Page number 69"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kW = 150.0 #Power rating of Shunt generator(kW)\n",
+ "V_1 = 250.0 #Voltage rating of Shunt generator(V)\n",
+ "V_a = V_1 #Voltage rating of Shunt generator(V)\n",
+ "R_f = 50.0 #Field resistance(ohm)\n",
+ "R_a = 0.05 #Armature resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "I_1 = kW*1000/V_1 #Full-load line current flowing to the load(A)\n",
+ "I_f = V_1/R_f #Field current(A)\n",
+ "I_a = I_f+I_1 #Armature current(A)\n",
+ "E_g = V_a+(I_a*R_a) #Full load generated voltage(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full-load line current flowing to the load , I_1 = %.f A' %I_1)\n",
+ "print('Case(b): Field current , I_f = %.f A' %I_f)\n",
+ "print('Case(c): Armature current , I_a = %.f A' %I_a)\n",
+ "print('Case(d): Full-load generated voltage , E_g = %.2f A' %E_g)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full-load line current flowing to the load , I_1 = 600 A\n",
+ "Case(b): Field current , I_f = 5 A\n",
+ "Case(c): Armature current , I_a = 605 A\n",
+ "Case(d): Full-load generated voltage , E_g = 280.25 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.2, Page number 72"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kW =100.0 #Power rating of the generator(kW)\n",
+ "V_1 = 500.0 #Voltage rating of hte generator(V)\n",
+ "R_a = 0.03 #Armature resistance(ohm)\n",
+ "R_f = 125.0 #Shunt field resistance(ohm)\n",
+ "R_s = 0.01 #Series field resistance(ohm)\n",
+ "I_d = 54.0 #Diverter current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "I_1 = kW*1000/V_1 #Full-load line current flowing to the load(A)\n",
+ "I_f = V_1/R_f #Shunt Field current(A)\n",
+ "I_a = I_f+I_1 #Armature current(A)\n",
+ "I_s = I_a-I_d #Series Field current(A)\n",
+ "R_d = I_s*R_s/I_d #Diverter resistance(ohm)\n",
+ "#Case(b)\n",
+ "E_g = V_1+I_a*R_a+I_s*R_s #Generated voltage at full load(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Diverter resistance at full load , R_d = %.4f \u03a9' %R_d)\n",
+ "print('Case(b): Generated voltage at full load , E_g = %.2f V' %E_g)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Diverter resistance at full load , R_d = 0.0278 \u03a9\n",
+ "Case(b): Generated voltage at full load , E_g = 507.62 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.3, Page number 75"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "E_orig = 150.0 #Armature voltage of the generator(V)\n",
+ "S_orig = 1800.0 #Speed of the generator(rpm)\n",
+ "S_final_a =2000.0 #Increased Speed of the generator(rpm)\n",
+ "S_final_b =1600.0 #Increased Speed of the generator(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "E_final_a = E_orig*(S_final_a/S_orig) #No-load voltage of the generator(V)\n",
+ "E_final_b = E_orig*(S_final_b/S_orig) #No-load voltage of the generator(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): No-load voltage of the separately excited generator , E_final = %.2f V' %E_final_a)\n",
+ "print('Case(b): No-load voltage of the separately excited generator , E_final = %.2f V' %E_final_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): No-load voltage of the separately excited generator , E_final = 166.67 V\n",
+ "Case(b): No-load voltage of the separately excited generator , E_final = 133.33 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.4, Page number 75"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S_final = 1200.0 #Speed of the generator(rpm)\n",
+ "E_orig_a = 64.3 #Armature voltage of the generator(V) for case a\n",
+ "S_orig_a = 1205.0 #Varied Speed of the generator(rpm)\n",
+ "E_orig_b = 82.9 #Armature voltage of the generator(V) for case b\n",
+ "S_orig_b = 1194.0 #Varied Speed of the generator(rpm)\n",
+ "E_orig_c = 162.3 #Armature voltage of the generator(V) for case c\n",
+ "S_orig_c = 1202.0 #Varied Speed of the generator(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "E_1 = E_orig_a*(S_final/S_orig_a) #No-load voltage of the generator(V)\n",
+ "E_2 = E_orig_b*(S_final/S_orig_b) #No-load voltage of the generator(V)\n",
+ "E_3 = E_orig_c*(S_final/S_orig_c) #No-load voltage of the generator(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): No-load voltage of the generator , E_1 = %.1f V at %.f rpm' %(E_1,S_final))\n",
+ "print('Case(b): No-load voltage of the generator , E_2 = %.1f V at %.f rpm' %(E_2,S_final))\n",
+ "print('Case(c): No-load voltage of the generator , E_3 = %.1f V at %.f rpm' %(E_3,S_final))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): No-load voltage of the generator , E_1 = 64.0 V at 1200 rpm\n",
+ "Case(b): No-load voltage of the generator , E_2 = 83.3 V at 1200 rpm\n",
+ "Case(c): No-load voltage of the generator , E_3 = 162.0 V at 1200 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.5, Page number 82"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 125.0 #Rated voltage of the shunt generator(V)\n",
+ "R_a = 0.15 #Armature resistance(ohm)\n",
+ "V_a = 0 #Terminal voltage across the load(V)\n",
+ "I_l = 96.0 #Load current(A)\n",
+ "I_f = 4.0 #Field current in A\n",
+ "\n",
+ "#Calculation\n",
+ "I_a = I_f+I_l #Armature current(A)\n",
+ "E_g = V_a+I_a*R_a #Voltage generated in the armature(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Voltage generated in the armature , E_g = %.f V' %E_g)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Voltage generated in the armature , E_g = 15 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.6, Page number 84"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_nl = 135.0 #No-load voltage of the shunt generator(V)\n",
+ "V_fl = 125.0 #Full-load voltage of the shunt generator(V)\n",
+ "\n",
+ "#Calculation\n",
+ "VR = (V_nl-V_fl)/V_fl*100 #Voltage regulation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Voltage regulation , VR = %.f percent' %VR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Voltage regulation , VR = 8 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.7, Page number 84"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "VR = 0.105 #Voltage regulation\n",
+ "V_fl = 250.0 #Full-load voltage of the shunt generator(V)\n",
+ "\n",
+ "#Calculation\n",
+ "V_nl = V_fl+(V_fl*VR) #No-load voltage of the generator(V)\n",
+ "\n",
+ "#Result\n",
+ "print('No-load voltage of the generator , V_nl = %.1f V' %V_nl)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "No-load voltage of the generator , V_nl = 276.2 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.8, Page number 88"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "N_f = 1000.0 #Shunt field winding(turns/pole)\n",
+ "N_s = 4.0 #Series field winding(turns/pole)\n",
+ "I_f = 0.2 #Field current(A)\n",
+ "I_a = 80.0 #Full-load armature current(A)\n",
+ "R_s =0.05 #Series field resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "I_s_N_s = I_f*N_f #Series field ampere-turns\n",
+ "I_s =(I_s_N_s)/N_s #Desired current in the series field required to produce voltage rise(A)\n",
+ "I_d = I_a-I_s #Diverter current(A)\n",
+ "R_d = (I_s*R_s)/I_d #Diverter resistance(ohm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Number of series field ampere-turns required for flat-compound operation , I_sN_s = %.f At' %I_s_N_s)\n",
+ "print('Case(b): Diverter resistance required for flat-compound operation , R_d = %.4f \u03a9' %R_d)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Number of series field ampere-turns required for flat-compound operation , I_sN_s = 200 At\n",
+ "Case(b): Diverter resistance required for flat-compound operation , R_d = 0.0833 \u03a9\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.9, Page number 89"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kW = 60.0 #Power rating of the generator(kW)\n",
+ "V = 240.0 #Voltage rating of the generator(V)\n",
+ "I_f = 3.0 #Increase in the field current(A)\n",
+ "OC_V = 275.0 #Over-compounded Voltage(V)\n",
+ "I_l = 250.0 #Rated load current(A)\n",
+ "N_f = 200.0 #Number of turns per pole in the shunt field winding \n",
+ "N_s = 5.0 #Number of turns per pole in the series field winding \n",
+ "R_f = 240.0 #Shunt field resistance(ohm)\n",
+ "R_s = 0.005 #Series field resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "I_s_N_s = I_f * N_f #Series field ampere-turns\n",
+ "I_s = (I_s_N_s)/N_s #Desired current in the series field required to produce voltage rise(A)\n",
+ "I_d = I_l-I_s #Diverter current(A)\n",
+ "R_d = (I_s*R_s)/I_d #Diverter resistance(ohm)\n",
+ "#Case(b)\n",
+ "NL_MMF = (V/R_f)*N_f #No-load MMF(At/pole)\n",
+ "I_f_N_f = NL_MMF\n",
+ "FL_MMF = I_f_N_f+I_s_N_s #Full-load MMF(At/pole)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Required diverter resistance , R_d = %.5f \u03a9' %R_d)\n",
+ "print('Case(b): Total air-gap MMF per pole at no load , No-load MMF = %.f At/pole' %NL_MMF)\n",
+ "print(' Total air-gap MMF per pole at full load , Full-load MMF = %.f At/pole' %FL_MMF)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Required diverter resistance , R_d = 0.00462 \u03a9\n",
+ "Case(b): Total air-gap MMF per pole at no load , No-load MMF = 200 At/pole\n",
+ " Total air-gap MMF per pole at full load , Full-load MMF = 800 At/pole\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.10, Page number 93"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kW= 50.0 #Power rating of the dynamo(kW)\n",
+ "V = 125.0 #Rated voltage(V)\n",
+ "S = 1800.0 #Speed of the dynamo(rpm)\n",
+ "I_f = 20.0 #Exciting field current(A)\n",
+ "Max_temp_rise = 25.0 #Maximum Temperature rise(degree celsius)\n",
+ "I_l = 400.0 #Load Current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Since the speed is reduced in half,we must reduce the kW rating in half.Consequently,the 25kW, 900rpm dynamo has the SAME size');\n",
+ "print('Case(b): Since we have cut the speed in half but maintained the same kW rating, the dynamo has TWICE the size as the original')\n",
+ "print('Case(c): HALF the size')\n",
+ "print('Case(d): SAME size')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Since the speed is reduced in half,we must reduce the kW rating in half.Consequently,the 25kW, 900rpm dynamo has the SAME size\n",
+ "Case(b): Since we have cut the speed in half but maintained the same kW rating, the dynamo has TWICE the size as the original\n",
+ "Case(c): HALF the size\n",
+ "Case(d): SAME size\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_4.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_4.ipynb new file mode 100755 index 00000000..5172c505 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_4.ipynb @@ -0,0 +1,1131 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 4: DC DYNAMO TORQUE RELATIONS-DC MOTORS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.1, Page number 100"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "d = 0.5 #Diameter of the coil(m)\n",
+ "l = 0.6 #Axial length of the coil(m)\n",
+ "B = 0.4 #Flux density(T)\n",
+ "I = 25.0 #Current carried by the coil(A)\n",
+ "theta = 60.0 #Angle between the useful force & the interpolar reference axis(degree)\n",
+ "\n",
+ "#Calculation\n",
+ "F = B*I*l #Force developed on each coil side(N)\n",
+ "f = F*math.sin(theta*math.pi/180) #Useful force at the instant the coil lies at an angle of 60\u00b0 w.r.t the interpolar ref axis(N)\n",
+ "r = d/2 #Radius of the coil(m)\n",
+ "T_c = f*r #Torque developed(N-m)\n",
+ "T_c1 = T_c*0.2248*3.281 #Torque developed in lb-ft by first method\n",
+ "T_c2 = T_c*0.737562 #Torque developed in lb-ft by second method\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Force developed on each coil side , F = %.f N' %F)\n",
+ "print('Case(b): Useful force at the instant the coil lies at an angle of 60\u00b0 w.r.t the interpolar ref axis , f = %.1f N' %f)\n",
+ "print('Case(c): Torque developed , T_c = %.1f N-m' %T_c)\n",
+ "print('Case(d): Torque developed by first method , 1.3 N.m * 0.2248 lb/N * 3.281 ft/m = %.2f lb-ft' %T_c1)\n",
+ "print(' Torque developed by second method , 1.3 N.m * 0.737562 lb.ft/N.m = %.2f lb-ft' %T_c2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Force developed on each coil side , F = 6 N\n",
+ "Case(b): Useful force at the instant the coil lies at an angle of 60\u00b0 w.r.t the interpolar ref axis , f = 5.2 N\n",
+ "Case(c): Torque developed , T_c = 1.3 N-m\n",
+ "Case(d): Torque developed by first method , 1.3 N.m * 0.2248 lb/N * 3.281 ft/m = 0.96 lb-ft\n",
+ " Torque developed by second method , 1.3 N.m * 0.737562 lb.ft/N.m = 0.96 lb-ft\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.2, Page number 100"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "d = 18.0 #Diameter of the coil(inches)\n",
+ "l = 24.0 #Axial length of the coil(inches)\n",
+ "B = 24000.0 #Flux density(lines/sq.inches)\n",
+ "I = 26.0 #Current carried by the coil(A)\n",
+ "theta = 60.0 #Angle between the useful force & the interpolar ref axis(degree)\n",
+ "\n",
+ "#Calculation\n",
+ "F = (B*I*l*10**-7)/1.13 #Force developed on each conductor(lb)\n",
+ "f = F*math.sin(theta*math.pi/180) #Useful force at the instant the coil lies at an angle of 60\u00b0 w.r.t the interpolar ref axis(lb)\n",
+ "r = d/2 #Radius of the coil(inches)\n",
+ "T_c = f*(r*1.0/12) #Torque developed(lb.ft/conductor)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Force developed on each conductor , F = %.3f lb' %F)\n",
+ "print('Case(b): Useful force , f = %.2f lb' %f)\n",
+ "print('Case(c): Torque developed , T_c = %.3f lb-ft/conductor' %T_c)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Force developed on each conductor , F = 1.325 lb\n",
+ "Case(b): Useful force , f = 1.15 lb\n",
+ "Case(c): Torque developed , T_c = 0.861 lb-ft/conductor\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.3, Page number 102"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "Z = 700.0 #Number of conductors\n",
+ "d = 24.0 #Diameter of the armature of the dc motor(inches)\n",
+ "l = 34.0 #Axial length of the coil(inches)\n",
+ "B = 50000.0 #Flux density(lines/sq.inches)\n",
+ "I = 25.0 #Current carried by the coil(A)\n",
+ "per = 0.7 #Conductors lying directly under poles\n",
+ "\n",
+ "#Calculation\n",
+ "F_av = (B*I*l*10**-7)/1.13*(Z*per) #Average total force tending to rotate the armature(lb) \n",
+ "r = d/2 #Radius of the coil(inches)\n",
+ "T_av = F_av*(r/12) #Armature torque(lb-ft)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Average total force tending to rotate the armature , F_av = %.f lb' %F_av)\n",
+ "print('Case(b): Armature torque , T_av = %.f lb-ft' %T_av)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Average total force tending to rotate the armature , F_av = 1843 lb\n",
+ "Case(b): Armature torque , T_av = 1843 lb-ft\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.4, Page number 102"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "slots = 120.0 #Number of armature slots\n",
+ "conductors_per_slot = 6.0 #Number of conductors per slot\n",
+ "B = 60000.0 #Flux density(lines/sq.inches)\n",
+ "d = 28.0 #Diameter of the armature(inches)\n",
+ "l = 14.0 #Axial length of the coil(inches)\n",
+ "A = 4.0 #Number of parallel paths\n",
+ "span = 0.72 #Pole arcs span 72% of the armature surface\n",
+ "I = 133.5 #Armature current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "Z_Ta = slots*conductors_per_slot*span #Number of armature conductors\n",
+ "F_t = (B*I*l)/(1.13*10**7 *A)*Z_Ta #Force developed(lb)\n",
+ "r = (d/2)/12 #Radius of the armature(feet)\n",
+ "T = F_t*r #Total torque developed(lb-ft)\n",
+ "\n",
+ "#Result\n",
+ "print('Total developed armature torque , T = %.f lb-ft' %T)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Total developed armature torque , T = 1500 lb-ft\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.5, Page number 103"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "slots = 120.0 #Number of armature slots\n",
+ "conductors_per_slot = 6.0 #Number of conductors per slot\n",
+ "B = 60000.0 #Flux density(lines/sq.inches)\n",
+ "d = 28.0 #Diameter of the armature(inches)\n",
+ "l = 14.0 #Axial length of the coil(inches)\n",
+ "A = 4.0 #Number of parallel paths\n",
+ "span = 0.72 #Pole arcs span 72% of the armature surface\n",
+ "T_a = 1500.0 #Total armature torque(lb-ft)\n",
+ "\n",
+ "#Calculation\n",
+ "Z = slots*conductors_per_slot #Number of armature conductors\n",
+ "r = (d/2)/12 #Radius of the armature(feet)\n",
+ "I_a = T_a*A*1.13*10**7/(B*l*Z*r*span) #Total external armature current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Total external armature current , I_a = %.1f A' %I_a)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Total external armature current , I_a = 133.5 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.6, Page number 104"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "phi_orig = 1.0 #Original flux\n",
+ "Ia_orig = 1.0 #Original armature current\n",
+ "T_orig = 150.0 #Original torque(N-m)\n",
+ "phi_new = 0.9 #New flux\n",
+ "Ia_new = 1.5 #New armature current\n",
+ "\n",
+ "#Calculation\n",
+ "T_new = T_orig*(phi_new/phi_orig)*(Ia_new/Ia_orig) #New torque produced(N-m)\n",
+ "\n",
+ "#Result\n",
+ "print('New torque produced , T = %.1f N-m' %T_new)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "New torque produced , T = 202.5 N-m\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.7, Page number 105"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "R_a = 0.25 #Armature resistance(ohm)\n",
+ "BD = 3.0 #Brush contact drop(V)\n",
+ "V = 120.0 #Applied voltage(V)\n",
+ "E_ca = 110.0 #counter EMF at a given load(V)\n",
+ "E_cb = 105 #Counter EMF due to application of additional load(V)\n",
+ "\n",
+ "#Calculation\n",
+ "I_a_a = (V-(E_ca+BD))/R_a #Armature current(A)\n",
+ "I_a_b = (V-(E_cb+BD))/R_a #Armature current(A)\n",
+ "del_Ec = ((E_ca-E_cb)/E_ca)*100 #Change in counter EMF(percent)\n",
+ "del_Ia = ((I_a_b-I_a_a)/I_a_a)*100 #Change in armature current(percent)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Aramature current , I_a = %.f A' %I_a_a)\n",
+ "print('Case(b): Aramature current due to additional load , I_a = %.f A' %I_a_b)\n",
+ "print('Case(c): Change in counter EMF , \u03b4E_c = %.2f percent' %del_Ec)\n",
+ "print(' Change in armature current , \u03b4I_a = %.1f percent' %del_Ia)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Aramature current , I_a = 28 A\n",
+ "Case(b): Aramature current due to additional load , I_a = 48 A\n",
+ "Case(c): Change in counter EMF , \u03b4E_c = 4.55 percent\n",
+ " Change in armature current , \u03b4I_a = 71.4 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.8, Page number 106"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_a = 120.0 #Rated terminal voltage of the DC motor(V)\n",
+ "R_a = 0.2 #Armature circuit resistance(ohm)\n",
+ "R_sh = 60.0 #Shunt field resistance(ohm)\n",
+ "I_l = 40.0 #Line current at full-load(A)\n",
+ "BD = 3.0 #Brush voltage drop(V)\n",
+ "S_orig = 1800.0 #Rated full-load speed(rpm)\n",
+ "per = 125.0/100 #Overload speed\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "I_f = V_a/R_sh #Field current(A)\n",
+ "I_a_fl = I_l-I_f #Armature current at full-load(A)\n",
+ "E_c_orig = V_a-(I_a_fl*R_a+BD) #Back EMF at full-load(V)\n",
+ "I_a_nl = I_a_fl/2 #Armature current at half-load(A)\n",
+ "E_c_final = V_a-(I_a_nl*R_a+BD) #Back EMF at half load(V)\n",
+ "S_a = S_orig*(E_c_final/E_c_orig) #Speed at full load(rpm)\n",
+ "#Case(b)\n",
+ "I_a_b = I_a_fl*per #Armature current at 125% overload(A)\n",
+ "E_c_b = V_a-(I_a_b*R_a+BD) #Back EMF at 125% overload(V)\n",
+ "S_b = S_orig*(E_c_b/E_c_orig) #Speed at 125% overload(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Speed at half load , S = %.f rpm' %S_a)\n",
+ "print('Case(b): Speed at an overload of 125 perecent , S = %.f rpm' %S_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Speed at half load , S = 1863 rpm\n",
+ "Case(b): Speed at an overload of 125 perecent , S = 1769 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.9, Page number 106"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "I_l_orig = 40.0 #Original line current(A)\n",
+ "I_l_final = 66.0 #Final line current(A)\n",
+ "phi_orig = 1.0 #Original flux\n",
+ "phi_final = 112.0/100 #Final flux\n",
+ "V_a = 120.0 #Rated terminal voltage of the DC motor(V)\n",
+ "R_sh_orig = 60.0 #Original Field circuit resistance(ohm)\n",
+ "R_sh_final = 50.0 #Decreased final field circuit resistance(ohm)\n",
+ "R_a = 0.2 #Armature circuit resistance(ohm)\n",
+ "BD = 3.0 #Brush voltage drop(V)\n",
+ "S_orig = 1800.0 #Rated full-load speed(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "I_f_orig = V_a/R_sh_orig #Original Field current(A)\n",
+ "I_a_orig = I_l_orig-I_f_orig #Original Armature current at full-load(A)\n",
+ "E_c_orig = V_a-(I_a_orig*R_a+BD) #Back EMF at full load(V)\n",
+ "I_f_final = V_a/R_sh_final #Final field current(A)\n",
+ "I_a_final = I_l_final-I_f_final #Final Armature current(A)\n",
+ "E_c_final = V_a-(I_a_final*R_a+BD) #Final EMF induced(V)\n",
+ "S = S_orig*(E_c_final/E_c_orig)*(phi_orig/phi_final) #Final speed of the motor(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('Speed of the motor , S = %.f rpm' %S)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Speed of the motor , S = 1532 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.10, Page number 108"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "I_a_1 = 38.0 #Armature current at full-load(A) from example 4-8a\n",
+ "E_c_1 = 109.4 #Back EMF at full-load(V)\n",
+ "S_1 = 1800.0 #Speed at full-load(rpm)\n",
+ "I_a_2 = 19.0 #Armature current at half-load(A) from example 4-8a\n",
+ "E_c_2 = 113.2 #Back EMF at half-load(V)\n",
+ "S_2 = 1863.0 #Speed at half-load(rpm)\n",
+ "I_a_3 = 47.5 #Armature current at 125% overload(A) from example 4-8b\n",
+ "E_c_3 = 107.5 #Back EMF at 125% overload(V)\n",
+ "S_3 = 1769.0 #Speed at 125% overload(rpm)\n",
+ "I_a_4 = 63.6 #Armature current at overload(A) from example 4-9\n",
+ "E_c_4 = 104.3 #Back EMF at overload(V)\n",
+ "S_4 = 1532.0 #Speed at overload(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "P_d_1 = E_c_1*I_a_1 #Armature power developed at full-load(W)\n",
+ "P_d_2 = E_c_2*I_a_2 #Armature power developed at half-load(W)\n",
+ "P_d_3 = E_c_3*I_a_3 #Armature power developed at 125% overload(W)\n",
+ "P_d_4 = E_c_4*I_a_4 #Armature power developed at overload(W)\n",
+ "\n",
+ "#Result\n",
+ "print(' Example \\t I_a \\t E_c \\t Speed \\t P_d or (E_c*I_a)')\n",
+ "print(' _______________________________________________________________________')\n",
+ "print(' 4-8a \\t\\t %d \\t %.1f \\t %d \\t %d W at full-load' %(I_a_1,E_c_1,S_1,P_d_1))\n",
+ "print(' \\t\\t %d \\t %.1f \\t %d \\t %.f W at half-load' %(I_a_2,E_c_2,S_2,P_d_2))\n",
+ "print(' 4-8b \\t\\t %.1f \\t %.1f \\t %d \\t %d W at 125 percent overload' %(I_a_3,E_c_3,S_3,P_d_3))\n",
+ "print(' 4-9 \\t\\t %.1f \\t %.1f \\t %d \\t %d W at overload' %(I_a_4,E_c_4,S_4,P_d_4))\n",
+ "print(' _______________________________________________________________________')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ " Example \t I_a \t E_c \t Speed \t P_d or (E_c*I_a)\n",
+ " _______________________________________________________________________\n",
+ " 4-8a \t\t 38 \t 109.4 \t 1800 \t 4157 W at full-load\n",
+ " \t\t 19 \t 113.2 \t 1863 \t 2151 W at half-load\n",
+ " 4-8b \t\t 47.5 \t 107.5 \t 1769 \t 5106 W at 125 percent overload\n",
+ " 4-9 \t\t 63.6 \t 104.3 \t 1532 \t 6633 W at overload\n",
+ " _______________________________________________________________________\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.11, Page number 110"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "T_a = 6.5 #Torque(dyne-centimeters)\n",
+ "T_b = 10.6 #Torque in (gram-centimeters)\n",
+ "T_c = 12.2 #Torque in (ounce-inches)\n",
+ "\n",
+ "#Calculation\n",
+ "T_a_Nm = T_a*1.416*10**-5*7.0612*10**-3 #Torque(N-m)\n",
+ "T_a_lbft = T_a*1.416*10**-5*5.208*10**-3 #Torque(lb-ft)\n",
+ "T_b_Nm = T_b*(1/72.01)*7.0612*10**-3 #Torque(N-m)\n",
+ "T_b_lbft = T_b*(1/72.01)*5.208*10**-3 #Torque(lb-ft)\n",
+ "T_c_Nm = T_c*7.0612*10**-3 #Torque(N-m)\n",
+ "T_c_lbft = T_c*5.208*10**-3 #Torque(lb-ft)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Torque , T = %.1e N-m' %T_a_Nm)\n",
+ "print(' Torque , T = %.1e lb-ft' %T_a_lbft)\n",
+ "print('Case(b): Torque , T = %.2e N-m' %T_b_Nm)\n",
+ "print(' Torque , T = %.2e lb-ft' %T_b_lbft)\n",
+ "print('Case(c): Torque , T = %.3e N-m' %T_c_Nm)\n",
+ "print(' Torque , T = %.2e lb-ft' %T_c_lbft)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Torque , T = 6.5e-07 N-m\n",
+ " Torque , T = 4.8e-07 lb-ft\n",
+ "Case(b): Torque , T = 1.04e-03 N-m\n",
+ " Torque , T = 7.67e-04 lb-ft\n",
+ "Case(c): Torque , T = 8.615e-02 N-m\n",
+ " Torque , T = 6.35e-02 lb-ft\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.12, Page number 110"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_a = 120.0 #Rated terminal voltage of dc shunt motor(V)\n",
+ "R_a = 0.2 #Armature resistance(ohm)\n",
+ "BD = 2.0 #Brush drop(V)\n",
+ "I_a = 75.0 #Full-load armature current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "I_st = (V_a-BD)/R_a #Current at the instant of starting(A)\n",
+ "percentage = I_st/I_a*100 #Percentage at full load\n",
+ "\n",
+ "#Result\n",
+ "print('Current at the instant of starting , I_st = %.f A (Counter EMF is zero)' %I_st)\n",
+ "print('Percentage at full load = %d percent' %percentage)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Current at the instant of starting , I_st = 590 A (Counter EMF is zero)\n",
+ "Percentage at full load = 786 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.13, Page number 111"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_a = 120.0 #Rated terminal voltage of dc shunt motor(V)\n",
+ "R_a = 0.2 #Armature resistance(ohm)\n",
+ "BD = 2.0 #Brush drop(V)\n",
+ "I_a = 75.0 #Full-load armature current(A)\n",
+ "I_a_new = 1.5*I_a #Armature current at 150% rated load(A) \n",
+ "E_c_a = 0 #Back EMF at starting(V)\n",
+ "E_c_b = 0.25* V_a #Back EMF is 25% of Va at 150% rated load(V)\n",
+ "E_c_c = 0.5*V_a #Back EMF is 50% of Va at 150% rated load(V)\n",
+ "\n",
+ "#Calculation\n",
+ "R_s_a = (V_a-E_c_a-BD)/I_a_new-R_a #Starting resistance at starting(ohm)\n",
+ "R_s_b = (V_a-E_c_b-BD)/I_a_new-R_a #Starting resistance 25% of Va(ohm)\n",
+ "R_s_c = (V_a-E_c_c-BD)/I_a_new-R_a #Starting resistance 50% of Va(ohm)\n",
+ "E_c_d = V_a-(I_a*R_a+BD) #Counter EMF at full-load without starting resistance(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Starting resistance at the instant of starting , R_s = %.2f \u03a9' %R_s_a)\n",
+ "print('Case(b): Starting resistance at 25 percent of armature voltage , R_s = %.3f \u03a9' %R_s_b)\n",
+ "print('Case(c): Starting resistance at 50 percent of armature voltage , R_s = %.3f \u03a9' %R_s_c)\n",
+ "print('Case(d): Counter EMF at full-load without starting resistance , E_c = %.f V' %E_c_d)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Starting resistance at the instant of starting , R_s = 0.85 \u03a9\n",
+ "Case(b): Starting resistance at 25 percent of armature voltage , R_s = 0.582 \u03a9\n",
+ "Case(c): Starting resistance at 50 percent of armature voltage , R_s = 0.316 \u03a9\n",
+ "Case(d): Counter EMF at full-load without starting resistance , E_c = 103 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.14, Page number 115"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "T_orig = 160.0 #Original torque developed(lb-ft)\n",
+ "I_a_orig = 140.0 #Original armature current(A)\n",
+ "phi_f_orig = 1.6*10**6 #Original field flux(lines)\n",
+ "T_final_a = 190.0 #Final torque developed when reconnected as a cumulative compound motor(lb-ft)\n",
+ "I_a_b = 154.0 #Final armature current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "phi_f = phi_f_orig*(T_final_a/T_orig) #Field flux(lines)\n",
+ "percentage = (phi_f/phi_f_orig)*100-100 #Percentage increase in flux\n",
+ "phi_f_final = 1.1*phi_f #Final field flux(lines)\n",
+ "T_f = T_final_a*(I_a_b/I_a_orig)*(phi_f_final/phi_f) #Final torque developed(lb-ft)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Flux increase due to series field , \u03a6_f = %.1f percent' %percentage)\n",
+ "print('Case(b): Final torque , T_f = %.f lb-ft' %T_f)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Flux increase due to series field , \u03a6_f = 18.8 percent\n",
+ "Case(b): Final torque , T_f = 230 lb-ft\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.15, Page number 115"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "I_a_orig = 25.0 #Original armature current(A)\n",
+ "I_a_final = 30.0 #Final armature current(A)\n",
+ "T_orig = 90.0 #Original torque developed(lb-ft)\n",
+ "phi_orig = 1.0 #Original flux\n",
+ "phi_final = 1.1 #Final flux\n",
+ "\n",
+ "#Calculation\n",
+ "T_a = T_orig*(I_a_final/I_a_orig)**2 #Final torque developed if field is unsaturated(lb-ft)\n",
+ "T_b = T_orig*(I_a_final/I_a_orig)*(phi_final/phi_orig) #Final torque developed when current rises to 30A and flux increases by 10%\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Torque when field is unsaturated , T = %.1f lb-ft' %T_a)\n",
+ "print('Case(b): Torque when current rises to 30 A and flux increases by 10 percent , T = %.1f lb-ft' %T_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Torque when field is unsaturated , T = 129.6 lb-ft\n",
+ "Case(b): Torque when current rises to 30 A and flux increases by 10 percent , T = 118.8 lb-ft\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.16, Page number 119"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_a = 230.0 #Rated armature voltage(V)\n",
+ "P = 10.0 #Rated power(hp)\n",
+ "S = 1250.0 #Rated speed(rpm)\n",
+ "R_A = 0.25 #Armature resistance(ohm)\n",
+ "R_p = 0.25 #Interpole resistance(ohm)\n",
+ "BD = 5.0 #Brush voltage drop(V)\n",
+ "R_s = 0.15 #Series field resistance(ohm)\n",
+ "R_sh = 230.0 #Shunt field resistance(ohm)\n",
+ "I_fl = 55.0 #Line current at rated load(A)\n",
+ "I_ol = 4.0 #No-load line current(A)\n",
+ "S_o = 1810.0 #No-load speed(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "R_a = R_A+R_p #Effective armature resistance(ohm)\n",
+ "I_f = V_a/R_sh #Field current(A)\n",
+ "I_a = I_ol-I_f #Armature current at no-load(A)\n",
+ "E_c_o = V_a-(I_a*R_a+BD) #No-load back EMF(V)\n",
+ "I_a_fl = I_fl-I_f #Armature current at full-load(A)\n",
+ "E_c_full_load = V_a-(I_a_fl*R_a+BD) #Back EMF at full-load(V)\n",
+ "S_r = S_o*(E_c_full_load/E_c_o) #Speed at rated load(rpm)\n",
+ "#Case(b)\n",
+ "P_d = E_c_full_load*I_a_fl #Internal power(W)\n",
+ "hp = P_d/746.0 #Internal horse power(hp)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Speed at rated load , S_r = %.f rpm' %S_r)\n",
+ "print('Case(b): Internal power in watts , P_d = %.f W' %P_d)\n",
+ "print(' Internal horse-power developed , P_d = %.1f hp' %hp)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Speed at rated load , S_r = 1603 rpm\n",
+ "Case(b): Internal power in watts , P_d = 10692 W\n",
+ " Internal horse-power developed , P_d = 14.3 hp\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.17, Page number 119"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_a = 230.0 #Rated armature voltage(V)\n",
+ "P = 10.0 #Rated power(hp)\n",
+ "S = 1250.0 #Rated speed(rpm)\n",
+ "R_A = 0.25 #Armature resistance(ohm)\n",
+ "R_p = 0.25 #Interpole resistance(ohm)\n",
+ "BD = 5.0 #Brush voltage drop in volt\n",
+ "R_s = 0.15 #Series field resistance in ohm\n",
+ "R_sh = 230.0 #Shunt field resistance in ohm\n",
+ "phi_1 = 1.0 #Original flux per pole\n",
+ "I_fl = 55.0 #Line current at rated load(A)\n",
+ "phi_2 = 1.25 #Flux increased by 25% due to long-shunt cumulative connection\n",
+ "I_ol = 4.0 #No-load line current(A)\n",
+ "S_o = 1810.0 #No-load speed(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "R_a = R_A+R_p #Effective armature resistance(ohm)\n",
+ "I_f = V_a/R_sh #Field current(A)\n",
+ "I_a = I_ol-I_f #Armature current at no-load(A)\n",
+ "E_c_o = V_a-(I_a*R_a+BD) #No-load back EMF(V)\n",
+ "I_a_fl = I_fl-I_f #Armature current at full-load(A)\n",
+ "#Case(a)\n",
+ "E_c_o1 = V_a-(I_a*R_a+I_a*R_s+BD) #No-load back EMF for long shunt cumulative connection(V)\n",
+ "S_n1 = S_o*(E_c_o1/E_c_o) #Speed at no-load(rpm)\n",
+ "#Case(b)\n",
+ "E_c_full_load_lsh = V_a-(I_a_fl*R_a+I_a_fl*R_s+BD ) #Back EMF at full-load for long-shunt cumulative motor(V)\n",
+ "S_r_lsh = S_n1*(E_c_full_load_lsh/E_c_o1)*(phi_1/phi_2) #Speed at rated load for long shunt connection(rpm)\n",
+ "#Case(c)\n",
+ "E_c_full_load = V_a-(I_a_fl*R_a+BD) #Back EMF at full-load(V)\n",
+ "S_r = S_o*(E_c_full_load/E_c_o) #Speed at rated load for shunt connection(rpm)\n",
+ "P_d = E_c_full_load*I_a_fl #Internal power(W)\n",
+ "hp = P_d/746.0 #Internal horse power(hp)\n",
+ "T_shunt = hp*5252/S_r #Internal torque at full-load for shunt motor(lb-ft)\n",
+ "I_a1 = I_a_fl #Armature current for shunt motor(A)\n",
+ "I_a2 = I_a_fl #Armature current for long-shunt cumulative motor(A)\n",
+ "T_comp = T_shunt*(phi_2/phi_1)*(I_a2/I_a1) #Internal torque at full load for long-shunt cumulative motor(lb-ft)\n",
+ "#Case(d)\n",
+ "Horsepower = (E_c_full_load_lsh*I_a_fl)/746 #Internal horsepower of compound motor based on flux increase(hp)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Speed at no-load , S_n1 = %d rpm' %S_n1)\n",
+ "print('Case(b): Speed at rated-load , S_r = %d rpm' %S_r_lsh)\n",
+ "print('Case(c): Internal torque at full-load with series field , T_comp = %.2f lb-ft' %T_comp)\n",
+ "print(' Internal torque at full-load without series field , T_shunt = %.2f lb-ft' %T_shunt)\n",
+ "print('Case(d): Internal horsepower of the compound motor , Horsepower = %.1f hp' %Horsepower)\n",
+ "print('Case(e): The internal hp exceeds the rated hp because the power developed in the motor must also overcome the internal mechanical rotational losses')\n",
+ "print('\\nNOTE: The change in obtained answer from that of textbook is due to more precision i.e more number of decimal places in this case')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Speed at no-load , S_n1 = 1806 rpm\n",
+ "Case(b): Speed at rated-load , S_r = 1230 rpm\n",
+ "Case(c): Internal torque at full-load with series field , T_comp = 58.68 lb-ft\n",
+ " Internal torque at full-load without series field , T_shunt = 46.94 lb-ft\n",
+ "Case(d): Internal horsepower of the compound motor , Horsepower = 13.7 hp\n",
+ "Case(e): The internal hp exceeds the rated hp because the power developed in the motor must also overcome the internal mechanical rotational losses\n",
+ "\n",
+ "NOTE: The change in obtained answer from that of textbook is due to more precision i.e more number of decimal places in this case\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.18, Page number 120"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 25.0 #Power rating of a series motor(hp)\n",
+ "V_a = 250.0 #Rated voltage(V)\n",
+ "R_a = 0.1 #Armature circuit resistance(ohm)\n",
+ "BD = 3.0 #Brush voltage drop(V)\n",
+ "R_s = 0.05 #Series field resistance(ohm)\n",
+ "I_a = 85.0 #Armature current(A)\n",
+ "I_a1 = 100.0 #Armature current(A)(case a)\n",
+ "I_a2 = 40.0 #Armature current(A)(case b)\n",
+ "S_1 = 600.0 #Speed(rpm)\n",
+ "R_d = 0.05 #Diverter resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "E_c2 = V_a-I_a1*(R_a+R_s)-BD #Back EMF when Ia = 100 A(V)\n",
+ "E_c1 = V_a-I_a*(R_a+R_s)-BD #Back EMF when Ia = 85 A(V)\n",
+ "S_2 = S_1*(E_c2/E_c1)*(I_a/I_a1) #Speed(rpm)\n",
+ "#Case(b)\n",
+ "E_c3 = V_a-I_a2*(R_a+R_s)-BD #Back EMF when Ia = 40 A(V)\n",
+ "S_3 = S_1*(E_c3/E_c1)*(I_a/I_a2) #Speed(rpm)\n",
+ "#Case(c)\n",
+ "R_sd = (R_s*R_d)/(R_s+R_d ) #Effective series field resistance(ohm)\n",
+ "E_c2_new = V_a-I_a1*(R_a+R_sd)-BD #Back EMF when Ia = 100 A(V)\n",
+ "S_2_new = S_1*(E_c2_new/E_c1)*(I_a/(I_a1/2)) #Speed(rpm) \n",
+ "E_c3_new = V_a-I_a2*(R_a+R_sd)-BD #Back EMF when Ia = 40 A(V)\n",
+ "S_3_new = S_1*(E_c3_new/E_c1)*(I_a/(I_a2/2)) #Speed(rpm) \n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Speed when current is 100 A , S_2 = %.f rpm' %S_2)\n",
+ "print('Case(b): Speed when current is 40 A , S_3 = %d rpm' %S_3)\n",
+ "print('Case(c): Speed when current is 100 A and using a diverter , S_2 = %.f rpm' %S_2_new)\n",
+ "print(' Speed when current is 40 A and using a diverter , S_3 = %.f rpm' %S_3_new)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Speed when current is 100 A , S_2 = 505 rpm\n",
+ "Case(b): Speed when current is 40 A , S_3 = 1311 rpm\n",
+ "Case(c): Speed when current is 100 A and using a diverter , S_2 = 1021 rpm\n",
+ " Speed when current is 40 A and using a diverter , S_3 = 2634 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.19, Page number 121"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S_n1 = 1810.0 #No-load speed(rpm) From Ex. 4-16\n",
+ "S_f1 = 1603.0 #Full-load speed(rpm)\n",
+ "S_n2 = 1806.0 #No-load speed(rpm) From Ex. 4-17\n",
+ "S_f2 = 1231.0 #Full-load speed(rpm)\n",
+ "S_n3 = 1311.0 #No-load speed(rpm) From Ex. 4-18\n",
+ "S_f3 = 505.0 #Full-load speed(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "SR_1 = (S_n1-S_f1)/S_f1*100 #Speed regulation for shunt motor(%)\n",
+ "SR_2 = (S_n2-S_f2)/S_f2*100 #Speed regulation for compound motor(%)\n",
+ "SR_3 = (S_n3-S_f3)/S_f3*100 #Speed regulation for series motor(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Speed regulation , SR(shunt) = %.1f percent' %SR_1)\n",
+ "print('Case(b): Speed regulation , SR(compound) = %.1f percent' %SR_2)\n",
+ "print('Case(c): Speed regulation , SR(series) = %.1f percent' %SR_3)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Speed regulation , SR(shunt) = 12.9 percent\n",
+ "Case(b): Speed regulation , SR(compound) = 46.7 percent\n",
+ "Case(c): Speed regulation , SR(series) = 159.6 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.20, Page number 121"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "SR = 0.1 #Speed regulation of a shunt motor \n",
+ "omega_f1 = 60.0*math.pi #Full-load speed(rad/s)\n",
+ "\n",
+ "#Calculation\n",
+ "omega_n1 = omega_f1*(1+SR) #No-load speed(rad/s)\n",
+ "S = omega_n1*(1/(2*math.pi))*(60.0/1) #No-load speed(rpm) \n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): No-load speed , \u03c9_n1 = %.f\u03c0 rad/s' %(omega_n1/math.pi))\n",
+ "print('Case(b): No-load speed , S = %.f rpm' %S)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): No-load speed , \u03c9_n1 = 66\u03c0 rad/s\n",
+ "Case(b): No-load speed , S = 1980 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.21, Page number 122"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S_int = 1603.0 #Internal rated speed(rpm)\n",
+ "S_ext = 1250.0 #External rated speed(rpm)\n",
+ "hp_int = 14.3 #Internal horsepower\n",
+ "hp_ext = 10.0 #External horsepower\n",
+ "\n",
+ "#Calculation\n",
+ "T_int = hp_int*5252/S_int #Internal torque(lb-ft)\n",
+ "T_ext = hp_ext*5252/S_ext #External torque(lb-ft)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Internal torque , T_int = %.2f lb-ft' %T_int)\n",
+ "print('Case(b): External torque , T_ext = %.1f lb-ft' %T_ext)\n",
+ "print('Case(c): Internal hp developed due electromagnetic torque is used internally to overcome mechanical losses of the motor reducing the torque available at its shaft to perform work')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Internal torque , T_int = 46.85 lb-ft\n",
+ "Case(b): External torque , T_ext = 42.0 lb-ft\n",
+ "Case(c): Internal hp developed due electromagnetic torque is used internally to overcome mechanical losses of the motor reducing the torque available at its shaft to perform work\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.22, Page number 123"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 50.0 #Power rating of the servo motor(W)\n",
+ "S = 3000.0 #Full-load speed of the servo motor(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "T_lbft = (7.04*P)/S #Output torque(lb-ft)\n",
+ "T_ounceinch = T_lbft*192 #Output torque(ounce-inches)\n",
+ "\n",
+ "#Result\n",
+ "print('Output torque available at the motor pulley , T = %.1f oz-in' %T_ounceinch)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Output torque available at the motor pulley , T = 22.5 oz-in\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.23, Page number 123"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 50.0 #Power rating of the servo motor(W)\n",
+ "S = 3000.0 #Full-load speed of the servo motor(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "S_rad_per_sec = S*2*math.pi/60 #Full-load speed of the servo motor(rad/s)\n",
+ "omega = 314.2 #Angular frequency(rad/s)\n",
+ "T_Nm = P/omega #Output torque(N-m)\n",
+ "T_ounceinch = T_Nm*1/(7.0612*10**-3) #Output torque(oz-in)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Motor speed in radians per second = %.1f rad/s' %S_rad_per_sec)\n",
+ "print('Case(b): Output torque in newton-meters , T = %.4f N-m' %T_Nm)\n",
+ "print('Case(c): Output torque in ounce-inches , T = %.1f oz-in' %T_ounceinch)\n",
+ "print('Case(d): Both answers are the same')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Motor speed in radians per second = 314.2 rad/s\n",
+ "Case(b): Output torque in newton-meters , T = 0.1591 N-m\n",
+ "Case(c): Output torque in ounce-inches , T = 22.5 oz-in\n",
+ "Case(d): Both answers are the same\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_5.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_5.ipynb new file mode 100755 index 00000000..b5f7d623 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_5.ipynb @@ -0,0 +1,113 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 5: ARMATURE REACTION AND COMMUTATION IN DYNAMOS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.1, Page number 140"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "conductors = 800.0 #Number of conductors \n",
+ "I_a = 1000.0 #Rated armature current(A)\n",
+ "P = 10.0 #Number of poles\n",
+ "pitch = 0.7 #Pole-face covers 70% of the pitch \n",
+ "a = P #Number of parallel paths for Simplex lap-wound\n",
+ "\n",
+ "#Calculation\n",
+ "Z = conductors/P #Number of armature conductors/path under each pole\n",
+ "Z_a = Z*pitch #Active armature conductors/pole\n",
+ "Z_p = Z_a/a #Number of pole face conductors/pole \n",
+ "\n",
+ "#Result\n",
+ "print('Number of pole face conductors/pole , Z_p = %.1f or %.f conductors/pole' %(Z_p,Z_p))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Number of pole face conductors/pole , Z_p = 5.6 or 6 conductors/pole\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.2, Page number 140"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "conductors = 800.0 #Number of conductors \n",
+ "I_a = 1000.0 #Rated armature current(A)\n",
+ "I_l = I_a #Load or total current entering the armature(A)\n",
+ "P = 10.0 #Number of poles\n",
+ "pitch = 0.7 #Pole-face covers 70% of the pitch \n",
+ "a = P #Number of parallel paths for Simplex lap-wound\n",
+ "alpha = 5.0 #Number of electrical degress that the brushes are shifted \n",
+ "\n",
+ "#Calculation\n",
+ "Z = conductors/P #Number of armature conductors/path under each pole\n",
+ "A_Z_per_pole = (Z*I_l)/(P*a) #Cross magnetizing ampere-conductors/pole\n",
+ "At_per_pole = (1.0/2)*(8000/1) #Ampere-turns/pole\n",
+ "frac_demag_At_per_pole = (2*alpha)/180*(At_per_pole) #Fraction of demagnetizing ampere-turns/pole\n",
+ "beta = 180-2*alpha #Cross-magnetizing electrical degrees\n",
+ "cross_mag_At_per_pole = (beta/180)*(At_per_pole) #Cross-magnetizing ampere-turns/pole\n",
+ "\n",
+ "#Result\n",
+ "print('(a) The cross-magnetizing ampere-conductors/pole = %.1f ampere-conductors/pole' %A_Z_per_pole)\n",
+ "print(' The cross-magnetizing ampere-turns/pole = %.1f At/pole' %At_per_pole)\n",
+ "print('(b) The fraction of demagnetizing ampere-turns/pole = %.1f At/pole' %frac_demag_At_per_pole)\n",
+ "print('(c) The cross-magnetizing ampere-turns/pole = %.f At/pole' %cross_mag_At_per_pole)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "(a) The cross-magnetizing ampere-conductors/pole = 800.0 ampere-conductors/pole\n",
+ " The cross-magnetizing ampere-turns/pole = 4000.0 At/pole\n",
+ "(b) The fraction of demagnetizing ampere-turns/pole = 222.2 At/pole\n",
+ "(c) The cross-magnetizing ampere-turns/pole = 3778 At/pole\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_6.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_6.ipynb new file mode 100755 index 00000000..8d4aa049 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_6.ipynb @@ -0,0 +1,505 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 6: AC DYNAMO VOLTAGE RELATIONS-ALTERNATORS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.1, Page number 160"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 1000.0 #Rating of the 3-phase alternator(kVA) \n",
+ "V_L = 4600.0 #Rated line voltage(V)\n",
+ "R_a = 2.0 #Armature resistance per phase(ohm)\n",
+ "X_s = 20.0 #Synchronous armature reactance per phase(ohm)\n",
+ "pf_a = 1.0 #Unity power factor\n",
+ "pf_b = 0.75 #Lagging power factor\n",
+ "\n",
+ "#Calculation\n",
+ "V_P = V_L/3**0.5 #Phase voltage(V)\n",
+ "I_P = kVA*1000/(3*V_P) #Phase current(A)\n",
+ "I_a = I_P #Armature current(A)\n",
+ "#Case(a)\n",
+ "E_g_a = complex((V_P+I_a*R_a),(I_a*X_s)) #Full-load generated voltage per phase(V/phase)\n",
+ "#Case(b)\n",
+ "sin_theta_b = (1-pf_b**2)**0.5 #Sin of angle of theta_b\n",
+ "E_g_b = complex((V_P*pf_b+ I_a*R_a),(V_P*sin_theta_b+I_a*X_s)) #Full-load generated voltage per phase(V/phase)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full-load generated voltage per phase at unity PF , E_g = %d V/phase' %(abs(E_g_a)))\n",
+ "print('Case(b): Full-load generated voltage per phase at 0.75 PF lagging , E_g = %d V/phase' %(abs(E_g_b)))\n",
+ "print('\\nNOTE: \u221a3 value is taken as %f instead of 1.73 as in textbook so slight variations in the obtained answer' %(3**0.5))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full-load generated voltage per phase at unity PF , E_g = 3840 V/phase\n",
+ "Case(b): Full-load generated voltage per phase at 0.75 PF lagging , E_g = 4820 V/phase\n",
+ "\n",
+ "NOTE: \u221a3 value is taken as 1.732051 instead of 1.73 as in textbook so slight variations in the obtained answer\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.2, Page number 161"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 1000.0 #Rating of the 3-phase alternator(kVA) \n",
+ "V_L = 4600.0 #Rated line voltage(V)\n",
+ "R_a = 2.0 #Armature resistance per phase(ohm)\n",
+ "X_s = 20.0 #Synchronous armature reactance per phase(ohm)\n",
+ "pf_a = 0.75 #Leading power factor\n",
+ "pf_b = 0.40 #Leading power factor\n",
+ "\n",
+ "#Calculation\n",
+ "V_P = V_L/3**0.5 #Phase voltage(V)\n",
+ "I_P = kVA*1000/(3*V_P) #Phase current(A)\n",
+ "I_a = I_P #Armature current(A)\n",
+ "#Case(a)\n",
+ "sin_theta_a = (1-pf_a**2)**0.5 #Sin of angle of theta_a\n",
+ "E_g_a = complex((V_P*pf_a+I_a*R_a),(V_P*sin_theta_a-I_a*X_s)) #Full-load generated voltage per phase(V/phase)\n",
+ "#Case(b)\n",
+ "sin_theta_b = (1-pf_b**2)**0.5 #Sin of angle of theta_b\n",
+ "E_g_b = complex((V_P*pf_b+ I_a*R_a),(V_P*sin_theta_b+-I_a*X_s)) #Full-load generated voltage per phase(V/phase)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full-load generated voltage per phase at 0.75 PF leading , E_g = %d V/phase' %(abs(E_g_a)))\n",
+ "print('Case(b): Full-load generated voltage per phase at 0.40 PF leading , E_g = %d V/phase' %(abs(E_g_b)))\n",
+ "print('\\nNOTE: \u221a3 value is taken as %f instead of 1.73 as in textbook so slight variations in the obtained answer' %(3**0.5))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full-load generated voltage per phase at 0.75 PF leading , E_g = 2366 V/phase\n",
+ "Case(b): Full-load generated voltage per phase at 0.40 PF leading , E_g = 1315 V/phase\n",
+ "\n",
+ "NOTE: \u221a3 value is taken as 1.732051 instead of 1.73 as in textbook so slight variations in the obtained answer\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.3, Page number 162"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "V_P = 2655.0 #Phase voltage(V) \n",
+ "E_g_a1 = 4820.0 #Full-load generated voltage per phase at 0.75 PF lagging(V/phase)\n",
+ "E_g_b1 = 3840.0 #Full-load generated voltage per phase at unity PF(V/phase)\n",
+ "E_g_a2 = 2366.0 #Full-load generated voltage per phase at 0.75 PF leading(V/phase)\n",
+ "E_g_b2 = 1315.0 #Full-load generated voltage per phase at 0.40 PF leading(V/phase)\n",
+ "\n",
+ "#Calculation\n",
+ "VR_a = (E_g_a1-V_P)/V_P*100 #Voltage regulation at 0.75 PF lagging(percent)\n",
+ "VR_b = (E_g_b1-V_P)/V_P*100 #Voltage regulation at unity PF(percent)\n",
+ "VR_c = (E_g_a2-V_P)/V_P*100 #Voltage regulation at 0.75 PF leading(percent)\n",
+ "VR_d = (E_g_b2-V_P)/V_P*100 #Voltage regulation at 0.75 PF leading(percent)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Voltage regulation at 0.75 PF lagging , VR = %.1f percent' %VR_a)\n",
+ "print('Case(b): Voltage regulation at unity PF , VR = %.1f percent' %VR_b)\n",
+ "print('Case(c): Voltage regulation at 0.75 PF leading , VR = %.2f percent' %VR_c)\n",
+ "print('Case(d): Voltage regulation at 0.40 PF leading , VR = %.1f percent' %VR_d)\n",
+ "print('\\nNOTE: \u221a3 value is taken as %f instead of 1.73 as in textbook so slight variations in the obtained answer' %(3**0.5))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Voltage regulation at 0.75 PF lagging , VR = 81.5 percent\n",
+ "Case(b): Voltage regulation at unity PF , VR = 44.6 percent\n",
+ "Case(c): Voltage regulation at 0.75 PF leading , VR = -10.89 percent\n",
+ "Case(d): Voltage regulation at 0.40 PF leading , VR = -50.5 percent\n",
+ "\n",
+ "NOTE: \u221a3 value is taken as 1.732051 instead of 1.73 as in textbook so slight variations in the obtained answer\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.4, Page number 168"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 100.0 #Rating of the 3-phase alternator(kVA)\n",
+ "V_L = 1100.0 #Line voltage of the 3-phase alternator(V)\n",
+ "E_gp1 = 6.0 #DC voltage between lines in dc resistance test(V)\n",
+ "I_a1 = 10.0 #DC current in lines dc resistance test(A)\n",
+ "pf_1 = 0.8 #Lagging power factor\n",
+ "pf_2 = 0.8 #Leading power factor\n",
+ "E_gp2 = 420.0 #Voltage between lines in open-circuit test(V)\n",
+ "I_f2 = 12.5 #DC Field current in open-circuit test(A)\n",
+ "I_f3 = 12.5 #DC Field current in short-circuit test(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "I_a_rated = kVA*1000/(V_L*3**0.5) #Rated current per phase(A)\n",
+ "I_a = 3**0.5*I_a_rated #Rated Line current(A)\n",
+ "V_l = E_gp1\n",
+ "R_dc = V_l/(2*I_a1) #Effective dc armature resistance(ohm/winding)\n",
+ "R_ac = R_dc*1.5 #Effective ac armature resistance(ohm/phase)\n",
+ "R_a = R_ac #Effective ac armature resistance from dc resistance test(ohm/phase)\n",
+ "Z_p = E_gp2/I_a #Synchronous impedance per phase(ohm/phase)\n",
+ "X_s = (Z_p**2-R_a**2)**0.5 #Synchronous reactance per phase(ohm/phase)\n",
+ "#Case(b)\n",
+ "V_p = V_L/3**0.5 #Phase voltage(V/phase)\n",
+ "V_fl = V_p #Full-load voltage(V/phase)\n",
+ "sin_theta_1 = (1-pf_1**2)**0.5 #Sin value of theta 1\n",
+ "E_gp_lag = complex((V_p*pf_1+I_a_rated*R_a),(V_p*sin_theta_1+I_a_rated*X_s)) #Generated voltage per phase at 0.8 PF lagging(V/phase)\n",
+ "V_nl_lag = abs(E_gp_lag) #No-load voltage(V/phase)\n",
+ "VR1 = (V_nl_lag-V_fl)/V_fl*100 #Voltage regulation at 0.8 PF lagging(%)\n",
+ "sin_theta_2 = (1-pf_2**2)**0.5 #Sin value of theta 2\n",
+ "E_gp_lead = complex((V_p*pf_2+I_a_rated*R_a),(V_p*sin_theta_2-I_a_rated*X_s)) #Generated voltage per phase at 0.8 PF leading(V/phase)\n",
+ "V_nl_lead = abs(E_gp_lead) #No-load voltage(V/phase)\n",
+ "VR2 = (V_nl_lead-V_fl)/V_fl*100 #Voltage regulation at 0.8 PF leading(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Effective resistance per phase , R_ac = %.2f \u03a9/phase' %R_ac)\n",
+ "print(' Synchronous impedance per phase , Z_p = %.2f \u03a9/phase' %Z_p)\n",
+ "print(' Synchronous reactance per phase , X_s = %.1f \u03a9/phase' %X_s)\n",
+ "print('Case(b): Voltage regulation at 0.8 PF lagging = %.f percent' %VR1)\n",
+ "print(' Voltage regulation at 0.8 PF leading = %.1f percent' %VR2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Effective resistance per phase , R_ac = 0.45 \u03a9/phase\n",
+ " Synchronous impedance per phase , Z_p = 4.62 \u03a9/phase\n",
+ " Synchronous reactance per phase , X_s = 4.6 \u03a9/phase\n",
+ "Case(b): Voltage regulation at 0.8 PF lagging = 29 percent\n",
+ " Voltage regulation at 0.8 PF leading = -13.4 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.5, Page number 169"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 100.0 #Rating of the 3-phase alternator(kVA)\n",
+ "V_L = 1100.0 #Line voltage of the 3-phase alternator(V)\n",
+ "E_gp1 = 6.0 #DC voltage between lines in dc resistance test(V)\n",
+ "I_a1 = 10.0 #DC current in lines dc resistance test(A)\n",
+ "pf_1 = 0.8 #Lagging power factor\n",
+ "pf_2 = 0.8 #Leading power factor\n",
+ "E_gp2 = 420.0 #Voltage between lines in open-circuit test(V)\n",
+ "I_f2 = 12.5 #DC Field current in open-circuit test(A)\n",
+ "I_f3 = 12.5 #DC Field current in short-circuit test(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "I_a_rated = kVA*1000/(V_L*3**0.5) #Rated current per phase(A)\n",
+ "I_L = I_a_rated #Rated Line current(A)\n",
+ "I_p = I_L/3**0.5 #Phase current(A)\n",
+ "I_a = I_p #Rated Line current(A)\n",
+ "Z_s = E_gp2/I_p #Synchronous impedance per phase(ohm/phase)\n",
+ "V_l = E_gp1\n",
+ "R_dc = V_l/(2*I_a1) #Effective dc armature resistance(ohm/winding)\n",
+ "R_ac = R_dc*1.5 #Effective ac armature resistance(ohm/phase)\n",
+ "R_eff = 3*R_ac #Effective resistance(ohm/phase)\n",
+ "R_a = R_eff\n",
+ "X_s = (Z_s**2-R_eff**2)**0.5 #Synchronous reactance per phase(ohm/phase)\n",
+ "#Case(b)\n",
+ "V_p = V_L #Phase voltage(V/phase)\n",
+ "V_fl = V_p #Full-load voltage(V/phase)\n",
+ "sin_theta_1 = (1-pf_1**2)**0.5 #Sin value of theta 1\n",
+ "E_gp_lag = complex((V_p*pf_1+I_a*R_a),(V_p*sin_theta_1+I_a*X_s)) #Generated voltage per phase at 0.8 PF lagging(V/phase)\n",
+ "V_nl_lag = abs(E_gp_lag) #No-load voltage(V/phase)\n",
+ "VR1 = (V_nl_lag-V_fl)/V_fl*100 #Voltage regulation at 0.8 PF lagging(%)\n",
+ "sin_theta_2 = (1-pf_2**2)**0.5 #Sin value of theta 2\n",
+ "E_gp_lead = complex((V_p*pf_2+I_a*R_a),(V_p*sin_theta_2-I_a*X_s)) #Generated voltage per phase at 0.8 PF leading(V/phase)\n",
+ "V_nl_lead = abs(E_gp_lead) #No-load voltage(V/phase)\n",
+ "VR2 = (V_nl_lead-V_fl)/V_fl*100 #Voltage regulation at 0.8 PF leading(%)\n",
+ "\n",
+ "print('Case(a): Effective resistance per phase , R_eff = %.2f \u03a9/phase' %R_eff)\n",
+ "print(' Synchronous impedance per phase , Z_s = %.2f \u03a9/phase' %Z_s)\n",
+ "print(' Synchronous reactance per phase , X_s = %.1f \u03a9/phase' %X_s)\n",
+ "print('Case(b): Voltage regulation at 0.8 PF lagging = %.f percent' %VR1)\n",
+ "print(' Voltage regulation at 0.8 PF leading = %.1f percent' %VR2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Effective resistance per phase , R_eff = 1.35 \u03a9/phase\n",
+ " Synchronous impedance per phase , Z_s = 13.86 \u03a9/phase\n",
+ " Synchronous reactance per phase , X_s = 13.8 \u03a9/phase\n",
+ "Case(b): Voltage regulation at 0.8 PF lagging = 29 percent\n",
+ " Voltage regulation at 0.8 PF leading = -13.4 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.6, Page number 172"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "E_L = 11000.0 #Line voltage generated(V)\n",
+ "kVA = 165000.0 #Rating of the alternator(kVA)\n",
+ "Z_p = 1.0 #Synchronous reactance(ohm)\n",
+ "R_p = 0.1 #Armature resistance(ohm/phase)\n",
+ "Z_r = 0.8 #Reactor reactance(ohm/phase)\n",
+ "\n",
+ "#Calculation\n",
+ "E_p = E_L/3**0.5 #Rated phase voltage(V)\n",
+ "I_p = kVA*1000/(3*E_p) #Rated current per phase(A)\n",
+ "#Case(a)\n",
+ "I_max_a = E_p/R_p #Maximum short-circuit current(A)\n",
+ "overload_a = I_max_a/I_p #Overload\n",
+ "#Case(b)\n",
+ "I_steady = E_p/Z_p #Sustained short-circuit current(A)\n",
+ "overload_b = I_steady/I_p #Overload\n",
+ "#Case(c)\n",
+ "Z_t = complex(R_p,Z_r) #Total reactance per phase(ohm)\n",
+ "I_max_c = E_p/abs(Z_t) #Maximum short-circuit current(A)\n",
+ "overload_c = abs(I_max_c)/I_p #Overload\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Maximum short-circuit current at instant of short-circuit , I_max = %.f A' %I_max_a)\n",
+ "print(' Overload = %.1f * rated current' %overload_a)\n",
+ "print('Case(b): Sustained short-circuit current , I_steady = %.f A' %I_steady)\n",
+ "print(' Overload = %.2f * rated current' %overload_b)\n",
+ "print('Case(c): Maximum short-circuit current with reactors , I_max = %.f A' %I_max_c)\n",
+ "print(' Overload = %.3f * rated current' %overload_c)\n",
+ "print('\\nNOTE: \u221a3 value is taken as %f instead of 1.73 as in textbook so slight variations in the obtained answer' %(3**0.5))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Maximum short-circuit current at instant of short-circuit , I_max = 63509 A\n",
+ " Overload = 7.3 * rated current\n",
+ "Case(b): Sustained short-circuit current , I_steady = 6351 A\n",
+ " Overload = 0.73 * rated current\n",
+ "Case(c): Maximum short-circuit current with reactors , I_max = 7877 A\n",
+ " Overload = 0.910 * rated current\n",
+ "\n",
+ "NOTE: \u221a3 value is taken as 1.732051 instead of 1.73 as in textbook so slight variations in the obtained answer\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.7, Page number 174"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA = 100.0 #Rating of the 3-phase alternator(kVA)\n",
+ "V_L = 1100.0 #Line voltage of the 3-phase alternator(V)\n",
+ "E_gp1 = 6.0 #DC voltage between lines in dc resistance test(V)\n",
+ "I_a1 = 10.0 #DC current in lines dc resistance test(A)\n",
+ "pf = 0.8 #Lagging power factor\n",
+ "E_gp2 = 420.0 #Voltage between lines in open-circuit test(V)\n",
+ "I_f2 = 12.5 #DC Field current in open-circuit test(A)\n",
+ "I_f3 = 12.5 #DC Field current in short-circuit test(A)\n",
+ "I_L = 52.5 #Rated line current(A)\n",
+ "I_a = I_L #Rated current per phase(A)\n",
+ "E_gp = complex(532,623) #Generated voltage at 0.8 PF lagging(V/phase)\n",
+ "X_s = 4.6 #Synchronous reactance per phase(ohm/phase)\n",
+ "V_p = 635.0 #Phase voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "P_T = 3**0.5*V_L*I_L*pf #Total output 3-phase power(W)\n",
+ "#Case(b)\n",
+ "P_p_b = P_T*10**-3/3.0 #Total output 3-phase power per phase(W)\n",
+ "#Case(d)\n",
+ "theta = math.acos(0.8)*180/math.pi #Phase angle of PF(degree)\n",
+ "theta_plus_deba = cmath.phase(E_gp)*180/math.pi #Phase angle of E_gp(degrees)\n",
+ "deba = theta_plus_deba-theta #Torque angle(degrees)\n",
+ "#Case(e)\n",
+ "P_p_e = abs(E_gp)*10**-3/X_s*V_p*math.sin(deba*math.pi/180) #Approximate output power per phase(W)\n",
+ "#Case(f)\n",
+ "P_p_f = abs(E_gp)*10**-3*I_a*math.cos(theta_plus_deba*math.pi/180) #Approximate output power per phase(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Total output 3-phase power , P_T = %.f W' %P_T)\n",
+ "print('Case(b): Output power per phase , P_p = %.2f kW' %P_p_b)\n",
+ "print('Case(c): Generated voltage , E_gp = %.1f\u2220%.1f\u00b0 V' %(abs(E_gp),cmath.phase(E_gp)*180/math.pi))\n",
+ "print('Case(d): Torque angle , \u03b4 = %.2f\u00b0 ' %deba)\n",
+ "print('Case(e): Approximate output power per phase , P_p = %.f W' %P_p_e)\n",
+ "print('Case(f): Approximate output power per phase , P_p = %.f W' %P_p_f)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Total output 3-phase power , P_T = 80021 W\n",
+ "Case(b): Output power per phase , P_p = 26.67 kW\n",
+ "Case(c): Generated voltage , E_gp = 819.2\u222049.5\u00b0 V\n",
+ "Case(d): Torque angle , \u03b4 = 12.64\u00b0 \n",
+ "Case(e): Approximate output power per phase , P_p = 25 W\n",
+ "Case(f): Approximate output power per phase , P_p = 28 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.8, Page number 174"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "E_g = 819.0 #Magnitude of generated voltage(V)\n",
+ "V_p = 635.0 #Phase voltage(V)\n",
+ "X_s = 4.6 #Synchronous reactance per phase(ohm/phase)\n",
+ "S = 1200.0 #Synchronous speed(rpm)\n",
+ "delta = 12.64 #Angle(degree)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "T_p_a = 7.04*E_g*V_p*math.sin(delta*math.pi/180)/(S*X_s) #Output torque per phase(lb-ft)\n",
+ "T_3ph_a = 3*T_p_a #Total output torque(lb-ft)\n",
+ "#Case(b)\n",
+ "omega = S*2*math.pi/60 #Speed(rad/s)\n",
+ "T_p_b = E_g*V_p*math.sin(delta*math.pi/180)/(omega*X_s) #Output torque per phase(N-m)\n",
+ "T_3ph_b = 3*T_p_b #Total output torque(N-m)\n",
+ "#Case(c)\n",
+ "T_p_c = T_p_a*1.356 #Output torque per phase(N-m)\n",
+ "T_3ph_c = 3.0*T_p_c #Total output torque(N-m)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Output torque per phase , T_p = %.f lb-ft' %T_p_a)\n",
+ "print(' Total output torque , T_3\u03c6 = %.f lb-ft' %T_3ph_a)\n",
+ "print('Case(b): Output torque per phase , T_p = %.f N-m' %T_p_b)\n",
+ "print(' Total output torque , T_3\u03c6 = %.f N-m' %T_3ph_b)\n",
+ "print('Case(c): Output torque per phase , T_p = %.f N-m' %T_p_c)\n",
+ "print(' Total output torque , T_3\u03c6 = %.f N-m' %T_3ph_c)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Output torque per phase , T_p = 145 lb-ft\n",
+ " Total output torque , T_3\u03c6 = 435 lb-ft\n",
+ "Case(b): Output torque per phase , T_p = 197 N-m\n",
+ " Total output torque , T_3\u03c6 = 591 N-m\n",
+ "Case(c): Output torque per phase , T_p = 197 N-m\n",
+ " Total output torque , T_3\u03c6 = 590 N-m\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_7.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_7.ipynb new file mode 100755 index 00000000..3b6bfaa8 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_7.ipynb @@ -0,0 +1,738 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 7: PARALLEL OPERATION"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.1, Page number 182"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "R_sh = 120.0 #Shunt field resistance(ohm)\n",
+ "R_a = 0.1 #Armature resistance(ohm)\n",
+ "V_L = 120.0 #Line voltage(V)\n",
+ "E_g1 = 125.0 #Generated voltage by dynamo A(V)\n",
+ "E_g2 = 120.0 #Generated voltage by dynamo B(V)\n",
+ "E_g3 = 114.0 #Generated voltage by dynamo C(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a) #1\n",
+ "I_gA = (E_g1-V_L)/R_a #Current in the generating dynamo A(A)\n",
+ "I_f = V_L/R_sh #Shunt field current(A)\n",
+ "I_a1 = I_gA+I_f #Armature current for dynamo A(A)\n",
+ "I_L1 = I_gA #Current delivered by dynamo A to the bus(A)\n",
+ "#2\n",
+ "I_gB = (E_g2-V_L)/R_a #Current in the generating dynamo B(A)\n",
+ "I_a2 = I_gB+I_f #Armature current for dynamo B(A)\n",
+ "I_L2 = I_gB #Current delivered by dynamo B to the bus(A)\n",
+ "#3\n",
+ "I_gC = (V_L-E_g3)/R_a #Current in the generating dynamo C(A)\n",
+ "I_a3 = I_gC #Armature current for dynamo C(A)\n",
+ "I_L3 = I_gC+I_f #Current received by dynamo C from the bus(A)\n",
+ "#Case(b) #1\n",
+ "P_LA = V_L*I_L1 #Power delivered to the bus by dynamo A(W)\n",
+ "P_gA = E_g1*I_a1 #Power generated by dynamo A(W)\n",
+ "#2\n",
+ "P_LB = V_L*I_L2 #Power delivered to the bus by dynamo B(W)\n",
+ "P_gB = E_g2*I_a2 #Power generated by dynamo B(W)\n",
+ "#3\n",
+ "P_LC = V_L*I_L3 #Power delivered by the bus to dynamo C(W)\n",
+ "P_gC = E_g3*I_a3 #Power generated by dynamo C(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a) 1: Line current delivered by dynamo A to the bus , I_LA = %.f A' %I_L1)\n",
+ "print(' Armature current , I_a = %.f A' %I_a1)\n",
+ "print(' 2: Line current delivered by dynamo B to the bus , I_LB = %.f A. Thus dynamo B is floating' %I_L2)\n",
+ "print(' Armature current , I_a = %.f A' %I_a2)\n",
+ "print(' 3: Line current received by dynamo C from the bus , I_LC = %.f A' %I_L3)\n",
+ "print(' Armature current , I_a = %.f A' %I_a3)\n",
+ "print('\\nCase(b) 1: Power delivered to the bus by dynamo A , P_LA = %.f W' %P_LA)\n",
+ "print(' Power generated by dynamo A , P_gA = %.f W' %P_gA)\n",
+ "print(' 2: Dynamo B neither receives or delivers power , P_LB = %.f W' %P_LB)\n",
+ "print(' Power generated by dynamo B to excite its field , P_gB = %.f W' %P_gB)\n",
+ "print(' 3: Power delivered by the bus to dynamo C , P_LC = %.f W' %P_LC)\n",
+ "print(' Internal power delivered in the direction of rotation of its prime mover , P_gC = %.f W' %P_gC)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a) 1: Line current delivered by dynamo A to the bus , I_LA = 50 A\n",
+ " Armature current , I_a = 51 A\n",
+ " 2: Line current delivered by dynamo B to the bus , I_LB = 0 A. Thus dynamo B is floating\n",
+ " Armature current , I_a = 1 A\n",
+ " 3: Line current received by dynamo C from the bus , I_LC = 61 A\n",
+ " Armature current , I_a = 60 A\n",
+ "\n",
+ "Case(b) 1: Power delivered to the bus by dynamo A , P_LA = 6000 W\n",
+ " Power generated by dynamo A , P_gA = 6375 W\n",
+ " 2: Dynamo B neither receives or delivers power , P_LB = 0 W\n",
+ " Power generated by dynamo B to excite its field , P_gB = 120 W\n",
+ " 3: Power delivered by the bus to dynamo C , P_LC = 7320 W\n",
+ " Internal power delivered in the direction of rotation of its prime mover , P_gC = 6840 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.2, Page number 182"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "R_a = 0.1 #Armature resistance(ohm)\n",
+ "R_f = 100.0 #Field circuit resistance(ohm)\n",
+ "V_L_b = 120.0 #Bus voltage(V)\n",
+ "V_L_a = 140.0 #Generated voltage of the generator(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_f = V_L_a #Voltage across the field(V)\n",
+ "I_f_a = V_f/R_f #Field current(A)\n",
+ "I_a_a = I_f_a #Armature current(A)\n",
+ "E_g_a = V_L_a+I_a_a*R_a #Generated EMF(V)\n",
+ "P_g_a = E_g_a*I_a_a #Generated power(W)\n",
+ "#Case(b)\n",
+ "I_a_b = (E_g_a-V_L_b)/R_a #Armature current(A)\n",
+ "I_f_b = V_L_b/R_f #Field current(A)\n",
+ "I_Lg = I_a_b-I_f_b #Generated line current(A)\n",
+ "P_L = V_L_b*I_Lg #Power generated across the lines(W)\n",
+ "E_g_b = V_L_a\n",
+ "P_g_b = E_g_b*I_a_b #Generated power(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Generated current before it is connected to the bus , I_a = %.1f A' %I_a_a)\n",
+ "print(' Generated power before it is connected to the bus , P_g = %.1f W' %P_g_a)\n",
+ "print('Case(b): Generated armature current after it is connected to the bus , I_a = %.1f A' %I_a_b)\n",
+ "print(' Generated line current after it is connected to the bus , I_Lg = %.1f A' %I_Lg)\n",
+ "print(' Generated power across the line after it is connected to the bus , P_g = %.f W' %P_L)\n",
+ "print(' Generated power after it is connected to the bus , P_g = %.f W' %P_g_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Generated current before it is connected to the bus , I_a = 1.4 A\n",
+ " Generated power before it is connected to the bus , P_g = 196.2 W\n",
+ "Case(b): Generated armature current after it is connected to the bus , I_a = 201.4 A\n",
+ " Generated line current after it is connected to the bus , I_Lg = 200.2 A\n",
+ " Generated power across the line after it is connected to the bus , P_g = 24024 W\n",
+ " Generated power after it is connected to the bus , P_g = 28196 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.3, Page number 183"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "R_a1 = 0.1 #Armature resistance of shunt generator 1(ohm)\n",
+ "R_a2 = 0.1 #Armature resistance of shunt generator 2(ohm)\n",
+ "R_a3 = 0.1 #Armature resistance of shunt generator 3(ohm)\n",
+ "R_L = 2.0 #Load resistance(ohm)\n",
+ "E_g1 = 127.0 #Voltage generated by shunt generator 1(V)\n",
+ "E_g2 = 120.0 #Voltage generated by shunt generator 2(V)\n",
+ "E_g3 = 119.0 #Voltage generated by shunt generator 3(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_L = ((E_g1/R_a1)+(E_g2/R_a2)+(E_g3/R_a3))/((1/R_a1)+(1/R_a2)+(1/R_a3)+(1/R_L))\n",
+ "#Case(b)\n",
+ "I_L1 = (E_g1-V_L)/R_a1 #Current delivered/received by generator 1(A)\n",
+ "I_L2 = (E_g2-V_L)/R_a2 #Current delivered/received by generator 2(A)\n",
+ "I_L3 = (E_g3-V_L)/R_a3 #Current delivered/received by generator 3(A)\n",
+ "I_L = -V_L/R_L #Current received by 2 ohm load(A)\n",
+ "#Case(c)\n",
+ "I_a1 = I_L1 #Armature current for generator 1(A)\n",
+ "I_a2 = I_L2 #Armature current for generator 2(A)\n",
+ "I_a3 = I_L3 #Armature current for generator 3(A)\n",
+ "P_g1 = E_g1*I_a1 #Power generated by generator 1(W)\n",
+ "P_g2 = E_g2*I_a2 #Power generated by generator 2(W)\n",
+ "P_g3 = E_g3*I_a3 #Power generated by generator 3(W)\n",
+ "#Case(d)\n",
+ "P_L1 = V_L*I_L1 #Power delivered/received from generator 1(W)\n",
+ "P_L2 = V_L*I_L2 #Power delivered/received from generator 2(W)\n",
+ "P_L3 = V_L*I_L3 #Power delivered/received from generator 3(W)\n",
+ "P_L = V_L*I_L #Power delivered/received from 2 ohm load(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Terminal bus voltage , V_L = %.f V' %V_L)\n",
+ "print('Case(b): Current delivered to the bus by generator 1 , I_L1 = %.f A (to bus)' %I_L1)\n",
+ "print(' Current delivered to the bus by generator 2 , I_L2 = %.f A' %I_L2)\n",
+ "print(' Current received by the generator 3 from the bus , I_L3 = %.f A (from bus)' %I_L3)\n",
+ "print(' Current received from the bus by load , I_L3 = %.f A (from bus)' %I_L)\n",
+ "print('Case(c): Power generated by generator 1 , P_g1 = %.f W' %P_g1)\n",
+ "print(' Power generated by generator 2 , P_g2 = %.f W (floating)' %P_g2)\n",
+ "print(' Power generated by generator 3 , P_g3 = %.f W' %P_g3)\n",
+ "print('Case(d): Power delivered to the bus from generator 1 , P_L1 = %.f W' %P_L1)\n",
+ "print(' Power delivered to the bus from generator 2 , P_L2 = %.f W' %P_L2)\n",
+ "print(' Power received from the bus by generator 3 , P_L2 = %.f W' %P_L3)\n",
+ "print(' Power received from the bus by load , P_L = %.f W' %P_L)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Terminal bus voltage , V_L = 120 V\n",
+ "Case(b): Current delivered to the bus by generator 1 , I_L1 = 70 A (to bus)\n",
+ " Current delivered to the bus by generator 2 , I_L2 = 0 A\n",
+ " Current received by the generator 3 from the bus , I_L3 = -10 A (from bus)\n",
+ " Current received from the bus by load , I_L3 = -60 A (from bus)\n",
+ "Case(c): Power generated by generator 1 , P_g1 = 8890 W\n",
+ " Power generated by generator 2 , P_g2 = 0 W (floating)\n",
+ " Power generated by generator 3 , P_g3 = -1190 W\n",
+ "Case(d): Power delivered to the bus from generator 1 , P_L1 = 8400 W\n",
+ " Power delivered to the bus from generator 2 , P_L2 = 0 W\n",
+ " Power received from the bus by generator 3 , P_L2 = -1200 W\n",
+ " Power received from the bus by load , P_L = -7200 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.4, Page number 184"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P1 = 300.0 #Power rating of generator 1(kW)\n",
+ "P2 = 600.0 #Power rating of generator 2(kW)\n",
+ "V = 220.0 #Voltage rating of generator 1 and 2(V)\n",
+ "V_o = 250.0 #No-load voltage applied to both the generators(V)\n",
+ "V_1 = 230.0 #Terminal voltage(V)\n",
+ "V_2 = 240.0 #Terminal voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "kW1_a = (V_o-V_1)/(V_o-V)*P1 #Load carried by generator 1(kW)\n",
+ "kW2_a = (V_o-V_1)/(V_o-V)*P2 #Load carried by generator 2(kW)\n",
+ "#Case(b)\n",
+ "kW1_b = (V_o-V_2)/(V_o-V)*P1 #Load carried by generator 1(kW)\n",
+ "kW2_b = (V_o-V_2)/(V_o-V)*P2 #Load carried by generator 2(kW)\n",
+ "#Case(c)\n",
+ "frac_a = (V_o-V_1)/(V_o-V) #Fraction of rated kW carried by each generator\n",
+ "frac_b = (V_o-V_2)/(V_o-V) #Fraction of rated kW carried by each generator\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): When the terminal voltage is 230 V Generator 1 carries = %.f kW' %kW1_a)\n",
+ "print(' When the terminal voltage is 230 V Generator 2 carries = %.f kW' %kW2_a)\n",
+ "print('Case(b): When the terminal voltage is 240 V Generator 1 carries = %.f kW' %kW1_b)\n",
+ "print(' When the terminal voltage is 240 V Generator 2 carries = %.f kW' %kW2_b)\n",
+ "print('Case(c): Both generators carry no-load at 250 V ; %.3f rated load at %d V ; %.3f rated load at %d V ; and rated load at %d V ;' %(frac_b,V_2,frac_a,V_1,V))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): When the terminal voltage is 230 V Generator 1 carries = 200 kW\n",
+ " When the terminal voltage is 230 V Generator 2 carries = 400 kW\n",
+ "Case(b): When the terminal voltage is 240 V Generator 1 carries = 100 kW\n",
+ " When the terminal voltage is 240 V Generator 2 carries = 200 kW\n",
+ "Case(c): Both generators carry no-load at 250 V ; 0.333 rated load at 240 V ; 0.667 rated load at 230 V ; and rated load at 220 V ;\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.5, Page number 191"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "E_1 = 220.0 #Terminal voltage of alternator 1(V)\n",
+ "E_2 = 222.0 #Terminal voltage of alternator 2(V)\n",
+ "f_1 = 60.0 #Frequency of alternator 1(Hz)\n",
+ "f_2 = 59.5 #Frequency of alternator 2(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "E_max = (E_1+E_2)/2 #Maximum effective voltage across each lamp(V) \n",
+ "E_min = (E_2-E_1)/2 #Minimum effective voltage across each lamp(V) \n",
+ "f = f_1-f_2 #Frequency of the voltage across the lamps(Hz)\n",
+ "E_peak = E_max/0.7071 #Peak value of the voltage across each lamp(V)\n",
+ "n = (1.0/2)*f_1 #Number of maximum light pulsations per minute\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Maximum effective voltage across each lamp , E_max/lamp = %.f V (rms)' %E_max)\n",
+ "print(' Minimum effective voltage across each lamp , E_min/lamp = %.f V' %E_min)\n",
+ "print('Case(b): Frequency of the voltage across the lamps , f = %.1f Hz' %f)\n",
+ "print('Case(c): Peak value of the voltage across each lamp , E_peak = %.f V' %E_peak)\n",
+ "print('Case(d): Number of maximum light pulsations per minute , n = %.f pulsations/min' %n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Maximum effective voltage across each lamp , E_max/lamp = 221 V (rms)\n",
+ " Minimum effective voltage across each lamp , E_min/lamp = 1 V\n",
+ "Case(b): Frequency of the voltage across the lamps , f = 0.5 Hz\n",
+ "Case(c): Peak value of the voltage across each lamp , E_peak = 313 V\n",
+ "Case(d): Number of maximum light pulsations per minute , n = 30 pulsations/min\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.6, Page number 191"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "E_1 = 220.0 #Voltage generated by alternator 1(V)\n",
+ "E_2 = 220.0 #Voltage generated by alternator 2(V)\n",
+ "f_1 = 60.0 #Frequency of alternator 1(Hz)\n",
+ "f_2 = 58.0 #Frequency of alternator 2(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "E_max = (E_1+E_2)/2 #Maximum effective voltage across each lamp(V)\n",
+ "f = f_1-f_2 #Frequency of the voltage across the lamp(Hz)\n",
+ "E_min = (E_2-E_1)/2 #Minimum effective voltage across each lamp(V) \n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Maximum effective voltage across each lamp , E_max/lamp = %.f V' %E_max)\n",
+ "print(' Frequency of the voltage across each lamp , f = %.f Hz' %f)\n",
+ "print('Case(b): The voltages are equal and opposite in the local circuit')\n",
+ "print('Case(c): Minimum effective voltage across each lamp , E_min/lamp = %.f V' %E_min)\n",
+ "print(' Frequency of the voltage across each lamp , f = 0 Hz')\n",
+ "print('Case(d): The voltages are in phase in the local circuit')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Maximum effective voltage across each lamp , E_max/lamp = 220 V\n",
+ " Frequency of the voltage across each lamp , f = 2 Hz\n",
+ "Case(b): The voltages are equal and opposite in the local circuit\n",
+ "Case(c): Minimum effective voltage across each lamp , E_min/lamp = 0 V\n",
+ " Frequency of the voltage across each lamp , f = 0 Hz\n",
+ "Case(d): The voltages are in phase in the local circuit\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.7, Page number 193"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "E_1 = 220.0 #Terminal voltage of alternator 1(V) From Ex. 7-5\n",
+ "E_2 = 222.0 #Terminal voltage of alternator 2(V)\n",
+ "f_1 = 60.0 #Frequency of alternator 1(Hz)\n",
+ "f_2 = 59.5 #Frequency of alternator 2(Hz)\n",
+ "E1 = 220.0 #Voltage generated by alternator 1(V) From Ex. 7-6\n",
+ "E2 = 220.0 #Voltage generated by alternator 2(V)\n",
+ "f1 = 60.0 #Frequency of alternator 1(Hz)\n",
+ "f2 = 58.0 #Frequency of alternator 2(Hz)\n",
+ "R_a1 = 0.1 #Armature resistance of alternator 1(ohm)\n",
+ "R_a2 = 0.1 #Armature resistance of alternator 2(ohm)\n",
+ "X_a1 = 0.9 #Armature reactance of alternator 1(ohm)\n",
+ "X_a2 = 0.9 #Armature reactance of alternator 2(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "Z_1 = complex(R_a1,X_a1) #Effective impedance of alternator 1(ohm)\n",
+ "Z_2 = complex(R_a2,X_a2) #Effective impedance of alternator 2(ohm)\n",
+ "#In Ex.7-5\n",
+ "E_r = E_2-E_1 #Effective voltage generated(V) \n",
+ "I_s = E_r/(Z_1+Z_2) #Synchronizing current in the armature(A)\n",
+ "#In Ex.7-6\n",
+ "Er = E2 -E1 #Effective voltage generated(V)\n",
+ "Is = Er/(Z_1+Z_2) #Synchronizing current in the armature(A)\n",
+ "\n",
+ "#Result\n",
+ "print('In Ex.7-5 the synchronizing current in the armatures of both alternators , I_s = %.3f\u2220%.2f\u00b0 A' %(abs(I_s),cmath.phase(I_s)*180/math.pi))\n",
+ "print('In Ex.7-6 the synchronizing current in the armatures of both alternators , I_s = %.f\u2220%.f\u00b0 A' %(abs(Is),cmath.phase(Is)*180/math.pi))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "In Ex.7-5 the synchronizing current in the armatures of both alternators , I_s = 1.104\u2220-83.66\u00b0 A\n",
+ "In Ex.7-6 the synchronizing current in the armatures of both alternators , I_s = 0\u22200\u00b0 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.8, Page number 195"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "E_gp1 = 200.0 #Terminal voltage of alternator 1(V)\n",
+ "E_gp2 = 220.0 #Terminal voltage of alternator 2(V)\n",
+ "R_a1 = 0.2 #Armature resistance of alternator 1(ohm)\n",
+ "R_a2 = 0.2 #Armature resistance of alternator 2(ohm)\n",
+ "X_a1 = 2.0 #Armature reactance of alternator 1(ohm)\n",
+ "X_a2 = 2.0 #Armature reactance of alternator 1(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "Z_p1 = complex(R_a1,X_a1) #Effective impedance of alternator 1(ohm)\n",
+ "Z_p2 = complex(R_a2,X_a2) #Effective impedance of alternator 2(ohm)\n",
+ "E_r = (E_gp2-E_gp1) #Effective voltage generated(V)\n",
+ "I_s = E_r/(Z_p1+Z_p2) #Synchronizing current in the armature(A)\n",
+ "Is = abs(I_s) #Magnitude of Synchronizing current(A)\n",
+ "theta = cmath.phase(I_s)*180/math.pi #Angle of Synchronizing current(degree)\n",
+ "P_2 = E_gp2*Is*math.cos(theta*math.pi/180) #Generator action developed by alternator 2(W)\n",
+ "#Case(b)\n",
+ "P_1 = -E_gp1*Is*math.cos(theta*math.pi/180) #Synchronizing power received by alternator 1(W) \n",
+ "#Case(c)\n",
+ "P1 = abs(P_1) #Magnitude of P1(W)\n",
+ "losses = P_2-P1 #Power loss in both armatures(W)\n",
+ "check = E_r*Is*math.cos(theta*math.pi/180) #Verifying losses(W) by Eq.7-7\n",
+ "double_check = Is**2*(R_a1+R_a2) #Verifying losses(W) by Eq.7-7\n",
+ "#Case(d)\n",
+ "V_p2 = E_gp2-Is*abs(Z_p2) #Generator action(V)\n",
+ "V_p1 = E_gp1+Is*abs(Z_p1) #Motor action(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Generator action developed by alternator 2 , P_2 = %.1f W' %P_2)\n",
+ "print('Case(b): Synchronizing power received by alternator 1 , P_1 = %.1f W' %P_1)\n",
+ "print('Case(c): Power loss in both armature , Losses = %.f W' %losses)\n",
+ "print('Case(d): Terminal voltage of alternator 2 , V_p2 = %.f V (generator action)' %V_p2)\n",
+ "print(' Terminal voltage of alternator 1 , V_p2 = %.f V (motor action)' %V_p1)\n",
+ "print('Case(e): Phasor diagram is shown in Fig 7-14 in textbook page no 195')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Generator action developed by alternator 2 , P_2 = 108.9 W\n",
+ "Case(b): Synchronizing power received by alternator 1 , P_1 = -99.0 W\n",
+ "Case(c): Power loss in both armature , Losses = 10 W\n",
+ "Case(d): Terminal voltage of alternator 2 , V_p2 = 210 V (generator action)\n",
+ " Terminal voltage of alternator 1 , V_p2 = 210 V (motor action)\n",
+ "Case(e): Phasor diagram is shown in Fig 7-14 in textbook page no 195\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.9, Page number 199"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "E_2 = 230.0*cmath.exp(1j*180.0*math.pi/180) #Voltage generated by alternator 2(V)\n",
+ "E_1 = 230.0*cmath.exp(1j*20.0*math.pi/180) #Voltage generated by alternator 1(V)\n",
+ "Z = 2.01*cmath.exp(1j*84.3*math.pi/180) #Impedance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "E_r = E_2+E_1 #Total voltage generated by Alternator 1 and 2(V)\n",
+ "Z_1 = Z\n",
+ "Z_2 = Z\n",
+ "#Case(a)\n",
+ "I_s = E_r/(Z_1+Z_2) #Synchronizing current(A)\n",
+ "Is = abs(I_s) #Magnitude of Synchronizing current(A)\n",
+ "I_s_a = cmath.phase(I_s)*180/math.pi #Phase angle of Synchronizing current(degrees)\n",
+ "#Case(b)\n",
+ "E_gp1 = abs(E_1)\n",
+ "E_gp1_Is = (cmath.phase(E_1)*180/math.pi)-I_s_a #Angle(degree)\n",
+ "P_1 = E_gp1*Is*math.cos(E_gp1_Is*math.pi/180) #Synchronizing power developed by alternator 1(W)\n",
+ "#Case(c)\n",
+ "E_gp2 = abs(E_2)\n",
+ "E_gp2_Is = (cmath.phase(E_2)*180/math.pi)-I_s_a #Angle(degree)\n",
+ "P_2 = E_gp2*Is*math.cos(E_gp2_Is*math.pi/180) #Synchronizing power developed by alternator 2(W)\n",
+ "#Case(d)\n",
+ "P2 = abs(P_2);\n",
+ "losses = P_1-P2 #Losses in the armature(W)\n",
+ "theta = cmath.phase(Z)*180/math.pi #Angle(degree)\n",
+ "check = abs(E_r)*Is*math.cos(theta*math.pi/180) #Verifying losses(W) by Eq.7-7\n",
+ "R_aT = 2*Z.real #Total armature resistance of alternator 1 and 2(ohm)\n",
+ "double_check = Is**2*R_aT #Verifying losses(W) by Eq.7-7\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Synchronizing current , I_s = %.2f\u2220%.1f\u00b0 A' %(Is,I_s_a))\n",
+ "print('Case(b): Synchronizing power developed by alternator 1 , P_1 = %.f W (power delivered to bus)' %P_1)\n",
+ "print('Case(c): Synchronizing power developed by alternator 2 , P_2 = %.f W (power received from bus)' %P_2)\n",
+ "print('Case(d): Losses in the armature , Losses = %.f W' %losses)\n",
+ "print('\\nNOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Synchronizing current , I_s = 19.87\u222015.7\u00b0 A\n",
+ "Case(b): Synchronizing power developed by alternator 1 , P_1 = 4557 W (power delivered to bus)\n",
+ "Case(c): Synchronizing power developed by alternator 2 , P_2 = -4400 W (power received from bus)\n",
+ "Case(d): Losses in the armature , Losses = 158 W\n",
+ "\n",
+ "NOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.10, Page number 200"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "E_2 = 230.0*cmath.exp(1j*180.0*math.pi/180) #Voltage generated by alternator 2(V)\n",
+ "E_1 = 230.0*cmath.exp(1j*20.0*math.pi/180) #Voltage generated by alternator 1(V)\n",
+ "Z = 6.0*cmath.exp(1j*50.0*math.pi/180) #Impedance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "E_r = E_2+E_1 #Total voltage generated by Alternator 1 and 2(V)\n",
+ "Z_1 = Z\n",
+ "Z_2 = Z\n",
+ "#Case(a)\n",
+ "I_s = E_r/(Z_1+Z_2) #Synchronizing current(A)\n",
+ "Is = abs(I_s) #Magnitude of Synchronizing current(A)\n",
+ "I_s_a = cmath.phase(I_s)*180/math.pi #Phase angle of Synchronizing current(degrees)\n",
+ "#Case(b)\n",
+ "E_gp1 = abs(E_1)\n",
+ "E_gp1_Is = (cmath.phase(E_1)*180/math.pi)-I_s_a #Angle(degree)\n",
+ "P_1 = E_gp1*Is*math.cos(E_gp1_Is*math.pi/180) #Synchronizing power developed by alternator 1(W)\n",
+ "#Case(c)\n",
+ "E_gp2 = abs(E_2)\n",
+ "E_gp2_Is = (cmath.phase(E_2)*180/math.pi)-I_s_a #Angle(degree)\n",
+ "P_2 = E_gp2*Is*math.cos(E_gp2_Is*math.pi/180) #Synchronizing power developed by alternator 2(W)\n",
+ "#Case(d)\n",
+ "P2 = abs(P_2);\n",
+ "losses = P_1-P2 #Losses in the armature(W)\n",
+ "theta = cmath.phase(Z)*180/math.pi #Angle(degree)\n",
+ "check = abs(E_r)*Is*math.cos(theta*math.pi/180) #Verifying losses(W) by Eq.7-7\n",
+ "R_aT = 2*Z.real #Total armature resistance of alternator 1 and 2(ohm)\n",
+ "double_check = Is**2*R_aT #Verifying losses(W) by Eq.7-7\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Synchronizing current , I_s = %.2f\u2220%.1f\u00b0 A' %(Is,I_s_a))\n",
+ "print('Case(b): Synchronizing power developed by alternator 1 , P_1 = %.f W (power delivered to bus)' %P_1)\n",
+ "print('Case(c): Synchronizing power developed by alternator 2 , P_2 = %.f W (power received from bus)' %P_2)\n",
+ "print('Case(d): Losses in the armature , Losses = %.f W' %losses)\n",
+ "print('\\nNOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Synchronizing current , I_s = 6.66\u222050.0\u00b0 A\n",
+ "Case(b): Synchronizing power developed by alternator 1 , P_1 = 1326 W (power delivered to bus)\n",
+ "Case(c): Synchronizing power developed by alternator 2 , P_2 = -984 W (power received from bus)\n",
+ "Case(d): Losses in the armature , Losses = 342 W\n",
+ "\n",
+ "NOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.11, Page number 207"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "import numpy\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_AB = 100.0*cmath.exp(1j*0.0*math.pi/180) #Voltage supplied across A & B(V)\n",
+ "V_BC = 100.0*cmath.exp(1j*-120.0*math.pi/180) #Voltage supplied across B & C(V)\n",
+ "V_CA = 100.0*cmath.exp(1j*120.0*math.pi/180) #Voltage supplied across C & A(V)\n",
+ "I1_1 = complex(6,0)\n",
+ "I1_2 = complex(-3,0)\n",
+ "I2_1 = complex(-3,0)\n",
+ "I2_2 = complex(3,-4)\n",
+ "V_1 = complex(100,0)\n",
+ "V_2 = complex(-50,-86.6)\n",
+ "\n",
+ "#Calculation\n",
+ "A = [[I1_1,I2_1],[I1_2,I2_2]] #Matrix containing mesh equations array\n",
+ "delta = numpy.linalg.det(A) #Determinant of A\n",
+ "#Case(a)\n",
+ "I_1 = numpy.linalg.det([[V_1,I2_1],[V_2,I2_2]])/delta #Mesh current I_1(A) \n",
+ "I_2 = numpy.linalg.det([[I1_1,V_1],[I1_2,V_2]])/delta #Mesh current I_2(A) \n",
+ "#Case(b)\n",
+ "I_A = I_1 #Line current(A)\n",
+ "I_B = I_2-I_1 #Line current(A)\n",
+ "I_C = -I_2 #Line current(A)\n",
+ "#Case(c)\n",
+ "Z_A = complex(3,0) #Impedance(ohm)\n",
+ "Z_B = complex(3,0) #Impedance(ohm)\n",
+ "Z_C = complex(0,-4) #Impedance(ohm)\n",
+ "V_AO = I_A*Z_A #Phase voltage(V)\n",
+ "V_BO = I_B*Z_B #Phase voltage(V)\n",
+ "V_CO = I_C*Z_C #Phase voltage(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Mesh current , I_1 = (%.3f%.4fj) A = %.1f\u2220%.2f\u00b0 A' %(I_1.real,I_1.imag,abs(I_1),cmath.phase(I_1)*180/math.pi))\n",
+ "print(' Mesh current , I_2 = (%.2f%.3fj) A = %.2f\u2220%.2f\u00b0 A' %(I_2.real,I_2.imag,abs(I_2),cmath.phase(I_2)*180/math.pi))\n",
+ "print('Case(a): Line current , I_A = (%.2f%.3fj) A = %.1f\u2220%.2f\u00b0 A' %(I_A.real,I_A.imag,abs(I_A),cmath.phase(I_A)*180/math.pi))\n",
+ "print(' Line current , I_B = (%.3f%.3fj) A = %.3f\u2220%.2f\u00b0 A' %(I_B.real,I_B.imag,abs(I_B),cmath.phase(I_B)*180/math.pi))\n",
+ "print(' Line current , I_C = (%.2f+%.3fj) A = %.2f\u2220%.2f\u00b0 A' %(I_C.real,I_C.imag,abs(I_C),cmath.phase(I_C)*180/math.pi))\n",
+ "print('Case(c): Phase voltage , V_AO = %.1f\u2220%.2f\u00b0 V' %(abs(V_AO),cmath.phase(V_AO)*180/math.pi))\n",
+ "print(' Phase voltage , V_BO = %.2f\u2220%.1f\u00b0 V' %(abs(V_BO),cmath.phase(V_BO)*180/math.pi))\n",
+ "print(' Phase voltage , V_CO = %.2f\u2220%.2f\u00b0 V' %(abs(V_CO),cmath.phase(V_CO)*180/math.pi))\n",
+ "print('Case(d): The phasor diagram is shown in fig 7-23b in textbook page no.208')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Mesh current , I_1 = (26.157-3.5589j) A = 26.4\u2220-7.75\u00b0 A\n",
+ " Mesh current , I_2 = (18.98-7.118j) A = 20.27\u2220-20.56\u00b0 A\n",
+ "Case(a): Line current , I_A = (26.16-3.559j) A = 26.4\u2220-7.75\u00b0 A\n",
+ " Line current , I_B = (-7.176-3.559j) A = 8.010\u2220-153.62\u00b0 A\n",
+ " Line current , I_C = (-18.98+7.118j) A = 20.27\u2220159.44\u00b0 A\n",
+ "Case(c): Phase voltage , V_AO = 79.2\u2220-7.75\u00b0 V\n",
+ " Phase voltage , V_BO = 24.03\u2220-153.6\u00b0 V\n",
+ " Phase voltage , V_CO = 81.09\u222069.44\u00b0 V\n",
+ "Case(d): The phasor diagram is shown in fig 7-23b in textbook page no.208\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_8.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_8.ipynb new file mode 100755 index 00000000..0d9acf34 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_8.ipynb @@ -0,0 +1,1279 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 8: AC DYNAMO TORQUE RELATIONS-SYNCHRONOUS MOTORS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.1, Page number 225"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 20.0 #Number of poles\n",
+ "hp = 40.0 #Power rating of the synchronous motor(hp)\n",
+ "V_L = 660.0 #Line voltage(V)\n",
+ "beta = 0.5 #At no-load, the rotor is retarded 0.5 mechanical degree from its synchronous position\n",
+ "X_s = 10.0 #Synchronous reactance(ohm)\n",
+ "R_a = 1.0 #Effective armature resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "alpha = P*(beta/2) #Rotor shift from the synchronous position in electrical degrees\n",
+ "#Case(b)\n",
+ "V_p = V_L/3**0.5 #Phase voltage(V)\n",
+ "E_gp = V_p #Generated voltage/phase at no-load(V)\n",
+ "E_r = complex((V_p-E_gp*math.cos(alpha*math.pi/180)),(E_gp*math.sin(alpha*math.pi/180))) #Resultant emf across the armature per phase(V/phase)\n",
+ "#Case(c)\n",
+ "Z_s = complex(R_a,X_s) #Synchronous impedance(ohm/phase)\n",
+ "I_a = E_r/Z_s #Armature current/phase(A/phase)\n",
+ "#Case(d)\n",
+ "Ia = abs(I_a) #Magnitude of armature current/phase(A/phase)\n",
+ "theta = cmath.phase(I_a)*180/math.pi #Phase angle of armature current(degree)\n",
+ "P_p = V_p*Ia*math.cos(theta*math.pi/180) #Power per phase drawn by the motor from the bus(W/phase)\n",
+ "P_t = 3*P_p #Total power drawn by the motor from the bus(W)\n",
+ "#Case(e)\n",
+ "P_a = 3*Ia**2*R_a #Armature power loss at no-load(W)\n",
+ "P_d = (P_t-P_a)/746.0 #Internal developed horsepower at no-load\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rotor shift from the synchronous position in electrical degrees , \u03b1 = %.f\u00b0 ' %alpha)\n",
+ "print('Case(b): Resultant EMF across the armature per phase , E_r = %.1f\u2220%.1f\u00b0 V/phase' %(abs(E_r),cmath.phase(E_r)*180/math.pi))\n",
+ "print('Case(c): Armature current per phase , I_a = %.2f\u2220%.1f\u00b0 A/phase' %(Ia,theta))\n",
+ "print('Case(d): Power per phase drawn by the motor from the bus , P_p = %.f W/phase' %P_p)\n",
+ "print(' Total power drawn by the motor from the bus , P_t = %.f W' %P_t)\n",
+ "print('Case(e): Armature power loss = %.f W' %P_a)\n",
+ "print(' Internal developed horsepower at no-load , P_d = %.f hp' %P_d)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rotor shift from the synchronous position in electrical degrees , \u03b1 = 5\u00b0 \n",
+ "Case(b): Resultant EMF across the armature per phase , E_r = 33.2\u222087.5\u00b0 V/phase\n",
+ "Case(c): Armature current per phase , I_a = 3.31\u22203.2\u00b0 A/phase\n",
+ "Case(d): Power per phase drawn by the motor from the bus , P_p = 1258 W/phase\n",
+ " Total power drawn by the motor from the bus , P_t = 3775 W\n",
+ "Case(e): Armature power loss = 33 W\n",
+ " Internal developed horsepower at no-load , P_d = 5 hp\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.2, Page number 226"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 20.0 #Number of poles\n",
+ "hp = 40.0 #Power rating of the synchronous motor(hp)\n",
+ "V_L = 660.0 #Line voltage(V)\n",
+ "beta = 5.0 #At no-load, the rotor is retarded 0.5 mechanical degree from its synchronous position\n",
+ "X_s = 10.0 #Synchronous reactance(ohm)\n",
+ "R_a = 1.0 #Effective armature resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "alpha = P*(beta/2) #Rotor shift from the synchronous position in electrical degrees\n",
+ "#Case(b)\n",
+ "V_p = V_L/3**0.5 #Phase voltage(V)\n",
+ "E_gp = V_p #Generated voltage/phase at no-load(V)\n",
+ "E_r = complex((V_p-E_gp*math.cos(alpha*math.pi/180)),(E_gp*math.sin(alpha*math.pi/180))) #Resultant emf across the armature per phase(V/phase)\n",
+ "#Case(c)\n",
+ "Z_s = complex(R_a,X_s) #Synchronous impedance(ohm/phase)\n",
+ "I_a = E_r/Z_s #Armature current/phase(A/phase)\n",
+ "#Case(d)\n",
+ "Ia = abs(I_a) #Magnitude of armature current/phase(A/phase)\n",
+ "theta = cmath.phase(I_a)*180/math.pi #Phase angle of armature current(degree)\n",
+ "P_p = V_p*Ia*math.cos(theta*math.pi/180) #Power per phase drawn by the motor from the bus(W/phase)\n",
+ "P_t = 3*P_p #Total power drawn by the motor from the bus(W)\n",
+ "#Case(e)\n",
+ "P_a = 3*Ia**2*R_a #Armature power loss at no-load(W)\n",
+ "P_d = (P_t-P_a)/746.0 #Internal developed horsepower at no-load\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rotor shift from the synchronous position in electrical degrees , \u03b1 = %.f\u00b0 ' %alpha)\n",
+ "print('Case(b): Resultant EMF across the armature per phase , E_r = %.f\u2220%.f\u00b0 V/phase' %(abs(E_r),cmath.phase(E_r)*180/math.pi))\n",
+ "print('Case(c): Armature current per phase , I_a = %.1f\u2220%.1f\u00b0 A/phase' %(Ia,theta))\n",
+ "print('Case(d): Power per phase drawn by the motor from the bus , P_p = %.f W/phase' %P_p)\n",
+ "print(' Total power drawn by the motor from the bus , P_t = %.f W' %P_t)\n",
+ "print('Case(e): Armature power loss = %.f W' %P_a)\n",
+ "print(' Internal developed horsepower at no-load , P_d = %.1f hp' %P_d)\n",
+ "print('\\nNOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rotor shift from the synchronous position in electrical degrees , \u03b1 = 50\u00b0 \n",
+ "Case(b): Resultant EMF across the armature per phase , E_r = 322\u222065\u00b0 V/phase\n",
+ "Case(c): Armature current per phase , I_a = 32.0\u2220-19.3\u00b0 A/phase\n",
+ "Case(d): Power per phase drawn by the motor from the bus , P_p = 11526 W/phase\n",
+ " Total power drawn by the motor from the bus , P_t = 34579 W\n",
+ "Case(e): Armature power loss = 3081 W\n",
+ " Internal developed horsepower at no-load , P_d = 42.2 hp\n",
+ "\n",
+ "NOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.3, Page number 237"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 6.0 #Number of poles\n",
+ "hp = 50.0 #Power rating of the synchronous motor(hp)\n",
+ "V_L = 440.0 #Line voltage(V)\n",
+ "alpha = 20.0 #At no-load, the rotor is retarded 0.5 mechanical degree from its synchronous position\n",
+ "X_s = 2.4 #Synchronous reactance(ohm)\n",
+ "R_a = 0.1 #Effective armature resistance(ohm)\n",
+ "E_gp_a = 240.0 #Generated phase voltage(V)\n",
+ "E_gp_b = 265.0 #Generated phase voltage(V)\n",
+ "E_gp_c = 290.0 #Generated phase voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_p = V_L /3**0.5 #Phase voltage(V)\n",
+ "E_ra = complex((V_p-E_gp_a*math.cos(alpha*math.pi/180)),(E_gp_a*math.sin(alpha*math.pi/180))) #Resultant emf\n",
+ "Z_s = complex(R_a,X_s) #Synchronous impedance(ohm)\n",
+ "I_ap1 = E_ra/Z_s #Armature current(A)\n",
+ "theta_1 = cmath.phase(I_ap1)*180/math.pi #Angle(degree)\n",
+ "pf_1 = math.cos(theta_1*math.pi/180) #Power factor\n",
+ "I_a1 = abs(I_ap1) #Magnitude of armature current(A)\n",
+ "P_d1 = 3*E_gp_a*I_a1*math.cos((160-theta_1)*math.pi/180) #Power drawn from the bus(W)\n",
+ "Horse_power1 = abs(P_d1)/746.0 #Horsepower developed by the armature(hp) \n",
+ "#Case(b)\n",
+ "E_rb = complex((V_p-E_gp_b*math.cos(alpha*math.pi/180)),(E_gp_b*math.sin(alpha*math.pi/180))) #Resultant emf\n",
+ "Z_s = complex(R_a,X_s) #Synchronous impedance(ohm)\n",
+ "I_ap2 = E_rb/Z_s #Armature current(A)\n",
+ "theta_2 = cmath.phase(I_ap2)*180/math.pi #Angle(degree)\n",
+ "pf_2 = math.cos(theta_2*math.pi/180) #Power factor\n",
+ "I_a2 = abs(I_ap2) #Magnitude of armature current(A)\n",
+ "P_d2 = 3*E_gp_b*I_a2*math.cos((160-theta_2)*math.pi/180) #Power drawn from the bus(W)\n",
+ "Horse_power2 = abs(P_d2)/746.0 #Horsepower developed by the armature(hp) \n",
+ "#Case(c)\n",
+ "E_rc = complex((V_p-E_gp_c*math.cos(alpha*math.pi/180)),(E_gp_c*math.sin(alpha*math.pi/180))) #Resultant emf\n",
+ "Z_s = complex(R_a,X_s) #Synchronous impedance(ohm)\n",
+ "I_ap3 = E_rc/Z_s #Armature current(A)\n",
+ "theta_3 = cmath.phase(I_ap3)*180/math.pi #Angle(degree)\n",
+ "pf_3 = math.cos(theta_3*math.pi/180) #Power factor\n",
+ "I_a3 = abs(I_ap3) #Magnitude of armature current(A)\n",
+ "P_d3 = 3*E_gp_c*I_a3*math.cos((160-theta_3)*math.pi/180) #Power drawn from the bus(W)\n",
+ "Horse_power3 = abs(P_d3)/746.0 #Horsepower developed by the armature(hp)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Armature current , I_ap = %.2f\u2220%.2f\u00b0 A' %(I_a1,theta_1))\n",
+ "print(' Power factor = %.4f lagging' %pf_1)\n",
+ "print(' Horsepower developed by the armature , Horsepower = %.1f hp' %Horse_power1)\n",
+ "print('Case(b): Armature current , I_ap = %.2f\u2220%.2f\u00b0 A' %(I_a2,theta_2))\n",
+ "print(' Power factor = %.f (Unity PF)' %pf_2)\n",
+ "print(' Horsepower developed by the armature , Horsepower = %.1f hp' %Horse_power2)\n",
+ "print('Case(c): Armature current , I_ap = %.f\u2220%.2f\u00b0 A' %(I_a3,theta_3))\n",
+ "print(' Power factor = %.4f leading' %pf_3)\n",
+ "print(' Horsepower developed by the armature , Horsepower = %.1f hp' %Horse_power3)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Armature current , I_ap = 36.17\u2220-16.77\u00b0 A\n",
+ " Power factor = 0.9575 lagging\n",
+ " Horsepower developed by the armature , Horsepower = 34.9 hp\n",
+ "Case(b): Armature current , I_ap = 37.79\u2220-0.78\u00b0 A\n",
+ " Power factor = 1 (Unity PF)\n",
+ " Horsepower developed by the armature , Horsepower = 38.0 hp\n",
+ "Case(c): Armature current , I_ap = 42\u222012.94\u00b0 A\n",
+ " Power factor = 0.9746 leading\n",
+ " Horsepower developed by the armature , Horsepower = 41.1 hp\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.4, Page number 240"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 2.0 #Number of poles\n",
+ "hp = 1000.0 #Power rating of the synchronous motor(hp)\n",
+ "V_L = 6000.0 #Line voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "R_a = 0.52 #Effective armature resistance(ohm)\n",
+ "X_s = 4.2 #Synchronous reactance(ohm)\n",
+ "P_t = 811.0 #Input power(kW)\n",
+ "PF = 0.8 #Power factor leading\n",
+ "\n",
+ "#Calculation\n",
+ "V_p = V_L/3**0.5 #Phase voltage(V)\n",
+ "I_L = P_t*1000/(3**0.5*V_L*PF) #Line current(A)\n",
+ "I_ap = I_L #Phase armature current(A)\n",
+ "Z_p = complex(R_a,X_s) #Impedance per phase(ohm)\n",
+ "Zp = abs(Z_p) #Magnitude of impedance per phase(ohm)\n",
+ "beta = cmath.phase(Z_p)*180/math.pi #Phase angle of impedance per phase(degree)\n",
+ "E_r = I_ap*Zp #EMF(V)\n",
+ "theta = math.acos(PF)*180/math.pi#Power factor angle(degree)\n",
+ "delta = beta+theta #Difference angle(degree)\n",
+ "E_gp_f = (E_r**2+V_p**2-2*E_r*V_p*math.cos(delta*math.pi/180))**0.5 #Generated phase voltage(V)\n",
+ "E_gp_g = complex((V_p+E_r*math.cos((180-delta)*math.pi/180)),(E_r*math.sin((180-delta)*math.pi/180))) #Generated phase voltage(V)\n",
+ "E_gp_h = complex((V_p*PF-I_ap*R_a),(V_p*math.sin(theta*math.pi/180)+I_ap*X_s)) #Generated phase voltage(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Line current , I_L = %.2f A' %I_L)\n",
+ "print(' Phase armature current , I_ap = %.2f A' %I_ap)\n",
+ "print('Case(b): Impedance per phase , Z_p\u2220\u03b2 = %.3f\u2220%.2f\u00b0 \u03a9' %(Zp,beta))\n",
+ "print('Case(c): Magnitude I_aZ_p = E_r = %.1f V' %E_r)\n",
+ "print('Case(d): Power factor angle , \u03b8 = %.2f\u00b0 leading' %theta)\n",
+ "print('Case(e): Difference angle at 0.8 PF , \u03b4 = %.2f\u00b0 ' %delta)\n",
+ "print('Case(f): Generated phase voltage , E_gp = %.f V' %E_gp_f)\n",
+ "print('Case(g): Generated phase voltage , E_gp = %.f\u2220%.2f\u00b0 V' %(abs(E_gp_g),cmath.phase(E_gp_g)*180/math.pi))\n",
+ "print('Case(h): Generated phase voltage , E_gp = %.f\u2220%.2f\u00b0 V' %(abs(E_gp_h),cmath.phase(E_gp_h)*180/math.pi))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Line current , I_L = 97.55 A\n",
+ " Phase armature current , I_ap = 97.55 A\n",
+ "Case(b): Impedance per phase , Z_p\u2220\u03b2 = 4.232\u222082.94\u00b0 \u03a9\n",
+ "Case(c): Magnitude I_aZ_p = E_r = 412.8 V\n",
+ "Case(d): Power factor angle , \u03b8 = 36.87\u00b0 leading\n",
+ "Case(e): Difference angle at 0.8 PF , \u03b4 = 119.81\u00b0 \n",
+ "Case(f): Generated phase voltage , E_gp = 3687 V\n",
+ "Case(g): Generated phase voltage , E_gp = 3687\u22205.58\u00b0 V\n",
+ "Case(h): Generated phase voltage , E_gp = 3687\u222042.45\u00b0 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.5, Page number 242"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "E_gp = 3687.0 #Generated phase voltage(V)\n",
+ "V_L = 6000.0 #Line voltage(V)\n",
+ "E_r = 412.8 #EMF(V)\n",
+ "V_p = V_L/3**0.5 #Phase voltage(V)\n",
+ "delta = 119.82 #Difference angle(degree)\n",
+ "theta = 36.87 #Power factor angle(degree)\n",
+ "R_a = 0.52 #Effective armature resistance(ohm)\n",
+ "X_s = 4.2 #Synchronous reactance(ohm)\n",
+ "I_a = 97.55 #Armature current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha_1 = math.acos((E_gp**2+V_p**2-E_r**2)/(2*E_gp*V_p))*180/math.pi #Torque angle(degree)\n",
+ "alpha_2 = math.asin(E_r*math.sin(delta*math.pi/180)/E_gp)*180/math.pi #Torque angle(degree)\n",
+ "alpha_3 = theta-math.atan((V_p*math.sin(theta*math.pi/180)+I_a*X_s)/(V_p*math.cos(theta*math.pi/180)-I_a*R_a))*180/math.pi #Torque angle(degree)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Torque angle , \u03b1 = %.2f\u00b0 '%alpha_1)\n",
+ "print('Case(b): Torque angle , \u03b1 = %.2f\u00b0 '%alpha_2)\n",
+ "print('Case(c): Torque angle , \u03b1 = %.2f\u00b0 '%alpha_3)\n",
+ "print('\\nNOTE: ERROR : Negative sign is not mentioned in angle \u03b1 part(c) in textbook answer')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Torque angle , \u03b1 = 5.57\u00b0 \n",
+ "Case(b): Torque angle , \u03b1 = 5.57\u00b0 \n",
+ "Case(c): Torque angle , \u03b1 = -5.58\u00b0 \n",
+ "\n",
+ "NOTE: ERROR : Negative sign is not mentioned in angle \u03b1 part(c) in textbook answer\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.6, Page number 242"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 2.0 #Number of poles\n",
+ "hp = 1000.0 #Power rating of the synchronous motor(hp)\n",
+ "V_L = 6000.0 #Line voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "P_t = 811.0 #Input power(kW)\n",
+ "PF = 0.8 #Power factor leading\n",
+ "E_gp = 3687.0 #Generated phase voltage(V)\n",
+ "I_a = 97.55 #Armature current(A)\n",
+ "E_gpI_a = 42.45 #Angle between Generated phase voltage and armature current(degree)\n",
+ "\n",
+ "#Calculation\n",
+ "P_p = E_gp*I_a*math.cos(E_gpI_a*math.pi/180)/1000 #Mechanical power developed per phase(kW)\n",
+ "P_t_a = 3*P_p #Total mechanical power developed(kW)\n",
+ "P_t_b = P_t_a/0.746 #Internal power developed at rated load(hp)\n",
+ "S = 120*f/P #Speed of the motor(rpm)\n",
+ "T_int = P_t_b*5252/S #Internal torque developed(lb-ft)\n",
+ "T_ext = hp*5252/3600 #External torque developed(lb-ft)\n",
+ "n = T_ext/T_int*100 #Motor efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Mechanical power developed in the armature per phase , P_p = %.3f kW' %P_p)\n",
+ "print(' Total Mechanical power developed in the armature , P_t = %.1f kW' %P_t_a)\n",
+ "print('Case(b): Internal power developed at rated load , P_t = %.1f hp' %P_t_b)\n",
+ "print('Case(c): Internal torque developed , T_int = %.f lb-ft' %T_int)\n",
+ "print('Case(d): Motor efficiency , \u03b7 = %.1f percent' %n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Mechanical power developed in the armature per phase , P_p = 265.386 kW\n",
+ " Total Mechanical power developed in the armature , P_t = 796.2 kW\n",
+ "Case(b): Internal power developed at rated load , P_t = 1067.2 hp\n",
+ "Case(c): Internal torque developed , T_int = 1557 lb-ft\n",
+ "Case(d): Motor efficiency , \u03b7 = 93.7 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.7, Page number 244"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P_o = 2000.0 #Total power consumed by a factory from the transformer(kW)\n",
+ "pf_tr = 0.6 #Lagging power factor at which power is consumed from the transformer\n",
+ "V_L = 6000.0 #Primary line voltage of a transformer(V)\n",
+ "P = 750.0 #Power expected to be delivered by the dc motor-generator(kW)\n",
+ "hp = 1000.0 #Rating of the motor(hp)\n",
+ "V_L_m = 6000.0 #Line voltage of a synchronous motor(V)\n",
+ "pf_sm = 0.8 #Leading power factor of the synchronous motor\n",
+ "pf_im = 0.8 #Lagging power factor of the induction motor\n",
+ "n = 0.92 #Efficiency of each motor\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "P_m_a = hp*746/n #Induction/synchronous motor load(kW)\n",
+ "I_1_a = P_m_a/(3**0.5*V_L*pf_im)*cmath.exp(1j*-math.acos(pf_im)) #Lagging current drawn by induction motor(A)\n",
+ "I_1_prime = P_o*1000/(3**0.5*V_L*pf_tr)*cmath.exp(1j*-math.acos(pf_tr)) #Original lagging factory load current(A)\n",
+ "I_TM = I_1_a+I_1_prime #Total load current(A)\n",
+ "angle_I_TM = cmath.phase(I_TM)*180/math.pi #Angle of total load current(degree)\n",
+ "PF_1 = math.cos(angle_I_TM*math.pi/180) #Overall sysytem PF\n",
+ "#Case(b)\n",
+ "I_s1 = P_m_a/(3**0.5*V_L*pf_sm)*cmath.exp(1j*math.acos(pf_sm)) #Leading current drawn by synchronous motor(A)\n",
+ "I_TSM = I_s1+I_1_prime #Total load current(A)\n",
+ "angle_I_TSM = cmath.phase(I_TSM)*180/math.pi #Angle of total load current(degree)\n",
+ "PF_2 = math.cos(angle_I_TSM*math.pi/180) #Overall sysytem PF\n",
+ "#Case(c)\n",
+ "percent_I_L = (abs(I_TM)-abs(I_TSM))/abs(I_TM)*100 #Percent reduction in total load current(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Total load current of the induction motor , I_TM = %.1f\u2220%.1f\u00b0 A' %(abs(I_TM),angle_I_TM))\n",
+ "print(' Power factor of the induction motor , Overall system PF = %.4f lagging' %PF_1)\n",
+ "print('Case(b): Total load current of the synchronous motor , I_TSM = %.1f\u2220%.1f\u00b0 A' %(abs(I_TSM),angle_I_TSM))\n",
+ "print(' Power factor of the synchronous motor , Overall system PF = %.1f lagging' %PF_2)\n",
+ "print('Case(c): Percent reduction in total load current = %.1f percent' %percent_I_L)\n",
+ "print('Case(d): PF improvement: Using the synchronous motor raises the total system PF from %.4f lagging to %.1f lagging' %(PF_1,PF_2))\n",
+ "print('\\nNOTE: Changes in obtained answer is due to precision and error in some data in the textbook solution')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Total load current of the induction motor , I_TM = 415.3\u2220-49.4\u00b0 A\n",
+ " Power factor of the induction motor , Overall system PF = 0.6513 lagging\n",
+ "Case(b): Total load current of the synchronous motor , I_TSM = 335.3\u2220-36.2\u00b0 A\n",
+ " Power factor of the synchronous motor , Overall system PF = 0.8 lagging\n",
+ "Case(c): Percent reduction in total load current = 19.3 percent\n",
+ "Case(d): PF improvement: Using the synchronous motor raises the total system PF from 0.6513 lagging to 0.8 lagging\n",
+ "\n",
+ "NOTE: Changes in obtained answer is due to precision and error in some data in the textbook solution\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.8, Page number 245"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 6.0 #Number of poles\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "V_L = 440.0 #Line voltage(V)\n",
+ "alpha = 20.0 #At no-load, the rotor is retarded 0.5 mechanical degree from its synchronous position\n",
+ "X_s = 2.4 #Synchronous reactance(ohm)\n",
+ "R_a = 0.1 #Effective armature resistance(ohm)\n",
+ "E_gp = 240.0 #Generated phase voltage(V)\n",
+ "V_p = V_L/3**0.5 #Phase voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "S = 120*f/P #Speed(rpm)\n",
+ "T_p = 7.04*E_gp*V_p*math.sin(alpha*math.pi/180)/(S*X_s) #Torque developed per phase(lb-ft)\n",
+ "Horsepower = 3*T_p*S/5252 #Total horsepower developed(hp)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Torque developed per phase , T_p = %.2f lb-ft' %T_p)\n",
+ "print('Case(b): Total horsepower developed , Horsepower = %.1f hp' %Horsepower)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Torque developed per phase , T_p = 50.97 lb-ft\n",
+ "Case(b): Total horsepower developed , Horsepower = 34.9 hp\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.9, Page number 251"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P_o = 2000.0 #Total power consumed by a factory(kW) \n",
+ "pf = 0.6 #Lagging power factor\n",
+ "V = 6000.0 #Line voltage(V)\n",
+ "loss = 275.0 #Synchronous capacitor losses(kW)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "S_o_conjugate = P_o/pf #Apparent complex power(kW)\n",
+ "sin_theta = (1-pf**2)**0.5 #Sin\u03b8\n",
+ "jQ_o = S_o_conjugate*sin_theta #Original kilovars of lagging load(kvar)\n",
+ "#Case(b)\n",
+ "jQ_c = -jQ_o #Kilovars of correction needed to bring the PF to unity(kvar)\n",
+ "#Case(c)\n",
+ "R = loss #Synchronous capacitor losses(kW)\n",
+ "S_c_conjugate = complex(R,jQ_c) #kVA rating of the synchronous capacitor(kVA)\n",
+ "angle_S_c_conjugate = cmath.phase(S_c_conjugate)*180/math.pi #Angle of #kVA rating of the synchronous capacitor(degree)\n",
+ "PF = math.cos(angle_S_c_conjugate*math.pi/180) #Power factor of the synchronous capacitor\n",
+ "#Case(d)\n",
+ "I_o = S_o_conjugate*1000/V #Original current drawn from the mains(A)\n",
+ "#Case(e)\n",
+ "P_f = P_o+loss #Total power(kW)\n",
+ "S_f = P_f #Total apparent power(kW)\n",
+ "I_f = S_f*1000/V #Final current drawn from the mains after correction(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Original kilovars of lagging load , jQ_o = j%.1f kvar' %jQ_o)\n",
+ "print('Case(b): Kilovars of correction needed to bring the PF to unity , -jQ_c = %.1fj kvar' %jQ_c)\n",
+ "print('Case(c): kVA rating of the synchronous capacitor , S_*c = %.f\u2220%.1f\u00b0 kVA' %(abs(S_c_conjugate),angle_S_c_conjugate))\n",
+ "print(' Power factor of the synchronous capacitor = %.3f leading' %PF)\n",
+ "print('Case(d): Original current drawn from the mains , I_o = %.1f A' %I_o)\n",
+ "print('Case(e): Final current drawn from the mains after correction , I_f = %.1f A' %I_f)\n",
+ "print('Case(f): See fig.8-25 in textbook page no.251')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Original kilovars of lagging load , jQ_o = j2666.7 kvar\n",
+ "Case(b): Kilovars of correction needed to bring the PF to unity , -jQ_c = -2666.7j kvar\n",
+ "Case(c): kVA rating of the synchronous capacitor , S_*c = 2681\u2220-84.1\u00b0 kVA\n",
+ " Power factor of the synchronous capacitor = 0.103 leading\n",
+ "Case(d): Original current drawn from the mains , I_o = 555.6 A\n",
+ "Case(e): Final current drawn from the mains after correction , I_f = 379.2 A\n",
+ "Case(f): See fig.8-25 in textbook page no.251\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.10, Page number 254"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 10000.0 #Rating of a system(kVA)\n",
+ "PF = 0.65 #Power factor of the system\n",
+ "PF_2 = 0.85 #Raised lagging PF\n",
+ "cost = 60.0 #Cost of the synchronous capacitor to improve the PF($/kVA)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "kW_a = kVA*PF #Power(kW)\n",
+ "sin_theta = (1-PF**2)**0.5 #Sin\u03b8\n",
+ "kvar = kVA*sin_theta #Reactive power(kvar)\n",
+ "kVA_a = kvar\n",
+ "cost_cap_a = kVA_a*cost #Cost of raising the PF to unity PF($)\n",
+ "#Case(b)\n",
+ "kVA_b = kW_a/PF_2 #kVA of final system(kVA)\n",
+ "sin_theta_b = (1-PF_2**2)**0.5 #Sin\u03b8\n",
+ "kvar_b = kVA_b*sin_theta_b #kvar of final system(kvar)\n",
+ "kvar_add = kvar-kvar_b #kvar of correction added(kvar)\n",
+ "kVA_b = kvar_add\n",
+ "cost_cap_b = kVA_b*cost #Cost of raising the PF to 0.85 PF($)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Cost of raising the PF to Unity PF = $%.f ' %cost_cap_a)\n",
+ "print('Case(b): Cost of raising the PF to 0.85 PF lagging = $%.f ' %cost_cap_b)\n",
+ "print('\\nNOTE: Slight variations in the obtained answer is due to non-approximation of the values while calculating in python')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Cost of raising the PF to Unity PF = $455961 \n",
+ "Case(b): Cost of raising the PF to 0.85 PF lagging = $214260 \n",
+ "\n",
+ "NOTE: Slight variations in the obtained answer is due to non-approximation of the values while calculating in python\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.11, Page number 255"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S_conjugate = 1000.0 #Apparent complex power(kVA)\n",
+ "PF = 0.6 #Lagging PF\n",
+ "\n",
+ "#Calculation\n",
+ "P_o = S_conjugate*PF #Active power dissipated by the load(kW)\n",
+ "sin_theta = (1-PF**2)**0.5 #Sin\u03b8\n",
+ "jQ_o = S_conjugate*sin_theta #Inductive reactive quadrature power drawn from and returned to the supply(kvar)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Active(true) power originally dissipated by load , P_o = %.f kW' %P_o)\n",
+ "print('Case(b): Inductive reactive quadrature power drawn from and returned to supply , +jQ_o = j%.f kvar' %jQ_o)\n",
+ "print('Case(c): The original power triangle is shown in Fig.8-26a in textbook page no.255')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Active(true) power originally dissipated by load , P_o = 600 kW\n",
+ "Case(b): Inductive reactive quadrature power drawn from and returned to supply , +jQ_o = j800 kvar\n",
+ "Case(c): The original power triangle is shown in Fig.8-26a in textbook page no.255\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.12, Page number 255"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S_conjugate = 1000.0 #Apparent complex power(kVA)\n",
+ "PF = 0.8 #Lagging PF\n",
+ "jQ_o = 800.0 #Inductive reactive quadrature power drawn from and returned to the supply(kvar)\n",
+ "P_o = 600.0 #Active power dissipated by the load(kW)\n",
+ "PF1 = 0.6 #Lagging PF from ex 8.11\n",
+ "\n",
+ "#Calculation\n",
+ "P_f = S_conjugate*PF #Final active power supplied by the alternator(kW)\n",
+ "sin_theta = (1-PF**2)**0.5 #Sin\u03b8\n",
+ "jQ_f = S_conjugate*sin_theta #Reactive power stored and returned to the supply(kvar)\n",
+ "P_a = P_f-P_o #Additional active power that may be supplied to new consumer(kW)\n",
+ "jQ_a = jQ_f-jQ_o #Correction kilovars required to raise PF from 0.6 to 0.8 lagging(kvar)\n",
+ "S_c = 0-jQ_a #Rating of correction capacitors needed(kVA)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Final active power supplied by the alternator , P_f = %.f kW' %P_f)\n",
+ "print('Case(b): Reactive power stored and returned to the supply , +jQ_f = j%.f kvar' %jQ_f)\n",
+ "print('Case(c): Additional active power that may be supplied to new consumer , P_a = %.f kW' %P_a)\n",
+ "print('Case(d): Correction kilovars required to raise PF from 0.6 to 0.8 lagging , -jQ_a = %.fj kvar' %jQ_a)\n",
+ "print('Case(e): Rating of correction capacitors needed to accomplish above correction , S_*c = %.f kVA' %S_c)\n",
+ "print('Case(f): The power tabulation grid is shown below:')\n",
+ "print('_____________________________________________________________________')\n",
+ "print('\\t P(kW) \\t \u00b1jQ(kvar) \\t S*(kVA) \\t Lagging cos\u03b8')\n",
+ "print('_____________________________________________________________________')\n",
+ "print('Original %.f \\t\\t j%.f \\t\\t %.f \\t\\t %.1f ' %(P_o,jQ_o,S_conjugate,PF1))\n",
+ "print('Added %.f \\t\\t %.fj \\t - \\t\\t - ' %(P_a,jQ_a))\n",
+ "print('Final %.f \\t\\t j%.f \\t\\t %.f \\t\\t %.1f ' %(P_f,jQ_f,S_conjugate,PF))\n",
+ "print('_____________________________________________________________________')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Final active power supplied by the alternator , P_f = 800 kW\n",
+ "Case(b): Reactive power stored and returned to the supply , +jQ_f = j600 kvar\n",
+ "Case(c): Additional active power that may be supplied to new consumer , P_a = 200 kW\n",
+ "Case(d): Correction kilovars required to raise PF from 0.6 to 0.8 lagging , -jQ_a = -200j kvar\n",
+ "Case(e): Rating of correction capacitors needed to accomplish above correction , S_*c = 200 kVA\n",
+ "Case(f): The power tabulation grid is shown below:\n",
+ "_____________________________________________________________________\n",
+ "\t P(kW) \t \u00b1jQ(kvar) \t S*(kVA) \t Lagging cos\u03b8\n",
+ "_____________________________________________________________________\n",
+ "Original 600 \t\t j800 \t\t 1000 \t\t 0.6 \n",
+ "Added 200 \t\t -200j \t - \t\t - \n",
+ "Final 800 \t\t j600 \t\t 1000 \t\t 0.8 \n",
+ "_____________________________________________________________________\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.13, Page number 256"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S_conjugate = 1000.0 #Apparent complex power(kVA)\n",
+ "PF = 1.0 #Unity PF\n",
+ "jQ_o = 800.0 #Inductive reactive quadrature power drawn from and returned to the supply(kvar)\n",
+ "P_o = 600.0 #Active power dissipated by the load(kW)\n",
+ "PF1 = 0.6 #Lagging PF from ex 8.11\n",
+ "\n",
+ "#Calculation\n",
+ "P_f = S_conjugate*PF #Final active power supplied by the alternator(kW)\n",
+ "sin_theta = (1-PF**2)**0.5 #Sin\u03b8\n",
+ "jQ_f = S_conjugate*sin_theta #Reactive power stored and returned to the supply(kvar)\n",
+ "P_a = P_f-P_o #Additional active power that may be supplied to new consumer(kW)\n",
+ "jQ_a = jQ_f-jQ_o #Correction kilovars required to raise PF from 0.6 to 0.8 lagging(kvar)\n",
+ "S_c = 0-jQ_a #Rating of correction capacitors needed(kVA)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Final active power supplied by the alternator , P_f = %.f kW' %P_f)\n",
+ "print('Case(b): Reactive power stored and returned to the supply , +jQ_f = j%.f kvar' %jQ_f)\n",
+ "print('Case(c): Additional active power that may be supplied to new consumer , P_a = %.f kW' %P_a)\n",
+ "print('Case(d): Correction kilovars required to raise PF from 0.6 to 0.8 lagging , -jQ_a = %.fj kvar' %jQ_a)\n",
+ "print('Case(e): Rating of correction capacitors needed to accomplish above correction , S_*c = %.f kVA' %S_c)\n",
+ "print('Case(f): The power tabulation grid is shown below:')\n",
+ "print('_____________________________________________________________________')\n",
+ "print('\\t P(kW) \\t \u00b1jQ(kvar) \\t S*(kVA) \\t cos\u03b8')\n",
+ "print('_____________________________________________________________________')\n",
+ "print('Original %.f \\t\\t j%.f \\t\\t %.f \\t\\t %.1f ' %(P_o,jQ_o,S_conjugate,PF1))\n",
+ "print('Added %.f \\t\\t %.fj \\t - \\t\\t - ' %(P_a,jQ_a))\n",
+ "print('Final %.f \\t\\t %.f \\t\\t %.f \\t\\t %.1f ' %(P_f,jQ_f,S_conjugate,PF))\n",
+ "print('_____________________________________________________________________')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Final active power supplied by the alternator , P_f = 1000 kW\n",
+ "Case(b): Reactive power stored and returned to the supply , +jQ_f = j0 kvar\n",
+ "Case(c): Additional active power that may be supplied to new consumer , P_a = 400 kW\n",
+ "Case(d): Correction kilovars required to raise PF from 0.6 to 0.8 lagging , -jQ_a = -800j kvar\n",
+ "Case(e): Rating of correction capacitors needed to accomplish above correction , S_*c = 800 kVA\n",
+ "Case(f): The power tabulation grid is shown below:\n",
+ "_____________________________________________________________________\n",
+ "\t P(kW) \t \u00b1jQ(kvar) \t S*(kVA) \t cos\u03b8\n",
+ "_____________________________________________________________________\n",
+ "Original 600 \t\t j800 \t\t 1000 \t\t 0.6 \n",
+ "Added 400 \t\t -800j \t - \t\t - \n",
+ "Final 1000 \t\t 0 \t\t 1000 \t\t 1.0 \n",
+ "_____________________________________________________________________\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.14, Page number 256"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P_o = 2000.0 #Load drawn by a factory(kW)\n",
+ "pf_o = 0.6 #Lagging PF\n",
+ "pf_f = 0.85 #lagging PF required\n",
+ "P_a = 275.0 #Losses in the synchronous capacitor(kW)\n",
+ "\n",
+ "#Calculation\n",
+ "S_o_conjugate = P_o/pf_o #Original kVA load drawn from the utility(kVA) \n",
+ "sin_theta_o = (1-pf_o**2)**0.5 #Sin\u03b8\n",
+ "jQ_o = S_o_conjugate*sin_theta_o #Original lagging kilovars(kvar)\n",
+ "P_f = P_o+P_a #Final system active power consumed from the utility(kW)\n",
+ "S_f_conjugate = (P_f/pf_f)*cmath.exp(1j*-math.acos(pf_f)) #Final kVA load drawn from the utility(kVA)\n",
+ "sin_theta_f = (1-pf_f**2)**0.5 #Sin\u03b8\n",
+ "jQ_f = abs(S_f_conjugate)*sin_theta_f #Final lagging kvar\n",
+ "jQ_a = jQ_f-jQ_o #Correction kvar produced by the synchronous capacitor(kvar)\n",
+ "S_a_conjugate = complex(P_a,jQ_a) #kVA rating of the synchronous capacitor(kVA)\n",
+ "angle_S_a_conjugate = cmath.phase(S_a_conjugate)*180/math.pi #Angle(degree)\n",
+ "pf_S_a_conjugate = math.cos(angle_S_a_conjugate*math.pi/180) #Leading PF\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Original kVA load drawn from the utility , S_*o = %.1f kVA' %S_o_conjugate)\n",
+ "print('Case(b): Original lagging kilovars , jQ_o = j%.f kvar' %jQ_o)\n",
+ "print('Case(c): Final system active power consumed from the utility , P_f = %.f kW' %P_f)\n",
+ "print('Case(d): Final kVA load drawn from the utility , S_*f = %.1f\u2220%.1f\u00b0 kVA' %(abs(S_f_conjugate),cmath.phase(S_f_conjugate)*180/math.pi))\n",
+ "print('Case(e): Correction kilovars produced by the synchronous capacitor , -jQ_a = %.fj kvar' %jQ_a)\n",
+ "print('Case(f): kVA rating of the synchronous capacitor , S_*a = %.f\u2220%.2f\u00b0 kVA' %(abs(S_a_conjugate),cmath.phase(S_a_conjugate)*180/math.pi))\n",
+ "print('Case(g): Power tabulation grid: ')\n",
+ "print('_____________________________________________________________________')\n",
+ "print('\\t P(kW) \\t \u00b1jQ(kvar) \\t S*(kVA) \\t cos\u03b8')\n",
+ "print('_____________________________________________________________________')\n",
+ "print('Original %.f \\t\\t j%.f \\t %.1f \\t\\t %.1f lag' %(P_o,jQ_o,S_o_conjugate,pf_o))\n",
+ "print('Added %.f \\t\\t %.fj \\t %.f \\t\\t %.3f lead' %(P_a,jQ_a,abs(S_a_conjugate),pf_S_a_conjugate))\n",
+ "print('Final %.f \\t\\t j%.f \\t %.1f \\t\\t %.2f lag' %(P_f,jQ_f,abs(S_f_conjugate),pf_f))\n",
+ "print('_____________________________________________________________________')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Original kVA load drawn from the utility , S_*o = 3333.3 kVA\n",
+ "Case(b): Original lagging kilovars , jQ_o = j2667 kvar\n",
+ "Case(c): Final system active power consumed from the utility , P_f = 2275 kW\n",
+ "Case(d): Final kVA load drawn from the utility , S_*f = 2676.5\u2220-31.8\u00b0 kVA\n",
+ "Case(e): Correction kilovars produced by the synchronous capacitor , -jQ_a = -1257j kvar\n",
+ "Case(f): kVA rating of the synchronous capacitor , S_*a = 1286\u2220-77.66\u00b0 kVA\n",
+ "Case(g): Power tabulation grid: \n",
+ "_____________________________________________________________________\n",
+ "\t P(kW) \t \u00b1jQ(kvar) \t S*(kVA) \t cos\u03b8\n",
+ "_____________________________________________________________________\n",
+ "Original 2000 \t\t j2667 \t 3333.3 \t\t 0.6 lag\n",
+ "Added 275 \t\t -1257j \t 1286 \t\t 0.214 lead\n",
+ "Final 2275 \t\t j1410 \t 2676.5 \t\t 0.85 lag\n",
+ "_____________________________________________________________________\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.15, Page number 257"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "S_f_conjugate = 3333.3 #Rating of alternator(kVA)\n",
+ "S_o_conjugate = complex(2275,1410) #Load(kVA)\n",
+ "PF = 0.8 #Lagging power factor\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "a = 1.0 #Co-efficient of x^2\n",
+ "b = 5332.0 #Co-efficient of x\n",
+ "c = -3947163.0 #Constant\n",
+ "sol_1 = (-b+(b**2-4*a*c)**0.5)/(2*a) #Solution 1\n",
+ "sol_2 = (-b-(b**2-4*a*c)**0.5)/(2*a) #Solution 1\n",
+ "x = sol_1\n",
+ "#Case(b)\n",
+ "P_a = PF*x #Added active power of the additional load(kW)\n",
+ "sin_theta = (1-PF**2)**0.5 #Sin\u03b8\n",
+ "Q_a = sin_theta*x #Added reactive power of the additional load(kvar)\n",
+ "#Case(c)\n",
+ "P_o = S_o_conjugate.real #Real power(kW)\n",
+ "Q_o = S_o_conjugate.imag #Reactive power(kvar)\n",
+ "P_f = P_o+P_a #Final active power supplied by alternator(kW)\n",
+ "Q_f = Q_o+Q_a #Final reactive power supplied by alternator(kvar)\n",
+ "#Case(d)\n",
+ "PF_final = P_f/S_f_conjugate #Final PF of the alternator\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Additional kVA load that may be added without overloading the alternator , x = S_*a = %.2f kVA' %x)\n",
+ "print('Case(b): Added active power of the additional load , P_a = %.1f kW' %P_a)\n",
+ "print(' Added reactive power of the additional load , Q_a = j%.2f kvar' %Q_a)\n",
+ "print('Case(c): Final active power supplied by alternator , P_f = %.1f kW' %P_f)\n",
+ "print(' Final reactive power supplied by alternator , Q_f = j%.1f kvar' %Q_f)\n",
+ "print('Case(d): Final PF of the alternator , PF = %.3f lagging' %PF_final)\n",
+ "print('Power tabulation grid: ')\n",
+ "print('_____________________________________________________________________')\n",
+ "print('\\t P(kW) \\t \u00b1jQ(kvar) \\t S*(kVA) \\t cos\u03b8')\n",
+ "print('_____________________________________________________________________')\n",
+ "print('Original %.f \\t\\t j%.f \\t %.1f \\t\\t %.2f lag' %(P_o,Q_o,abs(S_o_conjugate),math.cos(cmath.phase(S_o_conjugate))))\n",
+ "print('Added %.1fx \\t\\t j%.1fx \\t %.fx \\t\\t %.1f lag' %(PF,sin_theta,(PF**2+sin_theta**2),PF))\n",
+ "print('Final (%.f+%.1fx) \\t (%.f+%.1fx) \\t %.1f \\t\\t %.3f lag' %(P_o,PF,Q_o,sin_theta,S_f_conjugate,PF_final))\n",
+ "print('_____________________________________________________________________')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Additional kVA load that may be added without overloading the alternator , x = S_*a = 658.86 kVA\n",
+ "Case(b): Added active power of the additional load , P_a = 527.1 kW\n",
+ " Added reactive power of the additional load , Q_a = j395.32 kvar\n",
+ "Case(c): Final active power supplied by alternator , P_f = 2802.1 kW\n",
+ " Final reactive power supplied by alternator , Q_f = j1805.3 kvar\n",
+ "Case(d): Final PF of the alternator , PF = 0.841 lagging\n",
+ "Power tabulation grid: \n",
+ "_____________________________________________________________________\n",
+ "\t P(kW) \t \u00b1jQ(kvar) \t S*(kVA) \t cos\u03b8\n",
+ "_____________________________________________________________________\n",
+ "Original 2275 \t\t j1410 \t 2676.5 \t\t 0.85 lag\n",
+ "Added 0.8x \t\t j0.6x \t 1x \t\t 0.8 lag\n",
+ "Final (2275+0.8x) \t (1410+0.6x) \t 3333.3 \t\t 0.841 lag\n",
+ "_____________________________________________________________________\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.16, Page number 258"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "S_o_conjugate = complex(2275,1410) #Load(kVA)\n",
+ "theta_S_o_conjugate = cmath.phase(S_o_conjugate)*180/math.pi #Angle of load(degree)\n",
+ "S_a_conjugate = complex(527.1,395.32) #Additional load(kVA)\n",
+ "theta_S_a_conjugate = cmath.phase(S_a_conjugate)*180/math.pi #Angle of additional load(degree)\n",
+ "S_f_conjugate = complex(2802.1,1805.32) #Final load(kVA)\n",
+ "theta_S_f_conjugate = cmath.phase(S_f_conjugate)*180/math.pi #Angle of final load(degree)\n",
+ "\n",
+ "#Calculation\n",
+ "x = S_o_conjugate+S_a_conjugate+(-S_f_conjugate) #Tellegens theorem\n",
+ "\n",
+ "#Result\n",
+ "if(x==0):\n",
+ " print('Validity is checked Tellegens theorem , S_*o + S_*a + (_S_*f) = %.f' %abs(x))\n",
+ "else:\n",
+ " print('Validity is not checked')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Validity is checked Tellegens theorem , S_*o + S_*a + (_S_*f) = 0\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.17, Page number 258"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "kW = 40000.0 #Load on a factory(kW)\n",
+ "PF = 0.8 #Lagging PF\n",
+ "hp = 7500.0 #Power rating of the induction motor(hp)\n",
+ "PF_IM = 0.75 #Lagging PF of the induction motor\n",
+ "n = 0.91 #Efficiency of induction motor\n",
+ "PF_SM = 1.0 #Power factor of the synchronous motor\n",
+ "\n",
+ "#Calculation\n",
+ "kVA_original = kW/PF #Original kVA\n",
+ "sin_theta = (1-PF**2)**0.5 #Sin\u03b8\n",
+ "kvar_original = kVA_original*sin_theta #Original kvar\n",
+ "kW_IM = hp*746/(1000*n) #Induction motor(kW)\n",
+ "kVA_IM = kW_IM/PF_IM #Induction motor(kVA)\n",
+ "sin_theta_IM = (1-PF_IM**2)**0.5 #Sin\u03b8\n",
+ "kvar_IM = kVA_IM*sin_theta_IM #Induction motor(kvar)\n",
+ "kvar_final = kvar_original-kvar_IM #Final kvar\n",
+ "kVA_final = complex(kW,kvar_final) #Final kVA\n",
+ "angle_kVA_final = cmath.phase(kVA_final)*180/math.pi #Angle of Final kVA(degree)\n",
+ "PF_final = math.cos(angle_kVA_final*math.pi/180) #Final power factor\n",
+ "\n",
+ "#Result\n",
+ "print('Overall system PF using a unity PF synchronous motor , Final PF = %.3f lagging' %PF_final)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Overall system PF using a unity PF synchronous motor , Final PF = 0.852 lagging\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.18, Page number 259"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "kW = 40000.0 #Load on a factory(kW)\n",
+ "PF = 0.8 #Lagging PF\n",
+ "hp = 7500.0 #Power rating of the synchronous motor(hp)\n",
+ "PF_SM = 0.8 #Lagging PF of the synchronous motor\n",
+ "n = 0.91 #Efficiency of synchronous motor\n",
+ "hp_IM = 7500.0 #Power rating of the induction motor(hp)\n",
+ "PF_IM = 0.75 #Lagging PF of the induction motor\n",
+ "\n",
+ "\n",
+ "#Calculation\n",
+ "kVA_original = kW/PF #Original kVA\n",
+ "sin_theta = (1-PF**2)**0.5 #Sin\u03b8\n",
+ "kvar_original = kVA_original*sin_theta #Original kvar\n",
+ "kW_IM = hp_IM*746/(1000*n) #Induction motor(kW)\n",
+ "kVA_IM = kW_IM/PF_IM #Induction motor(kVA)\n",
+ "sin_theta_IM = (1-PF_IM**2)**0.5 #Sin\u03b8\n",
+ "kvar_IM = kVA_IM*sin_theta_IM #Induction motor(kvar)\n",
+ "kvar_final_IM = kvar_original-kvar_IM #Final kvar\n",
+ "kW_SM = hp*746/(1000*n) #synchronous motor(kW)\n",
+ "kVA_SM = kW_SM/PF_SM #synchronous motor(kVA)\n",
+ "sin_theta_SM = (1-PF_SM**2)**0.5 #Sin\u03b8\n",
+ "kvar_SM = kVA_SM*sin_theta_SM #synchronous(kvar)\n",
+ "kvar_final = kvar_original-kvar_SM-kvar_IM #Final kvar\n",
+ "kVA_final = complex(kW,kvar_final) #Final kVA\n",
+ "angle_kVA_final = cmath.phase(kVA_final)*180/math.pi #Angle of Final kVA(degree)\n",
+ "PF_final = math.cos(angle_kVA_final*math.pi/180) #Final power factor\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Overall system PF using a unity PF synchronous motor , Final PF = %.3f lagging' %PF_final)\n",
+ "print('Case(b): In Ex.8-17, a 6148 kVA, unity PF, 7500 hp synchronous motor is needed. In Ex.8-18, a 7685 kVA, 0.8 PF leading, 7500 hp synchronous motor is needed')\n",
+ "print(' Ex.8-18b shows that a 0.8 PF leading, 7500 hp synchronous motor must be physically larger than a unity PF, 7500 hp synchronous motor because of its higher kVA rating')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Overall system PF using a unity PF synchronous motor , Final PF = 0.895 lagging\n",
+ "Case(b): In Ex.8-17, a 6148 kVA, unity PF, 7500 hp synchronous motor is needed. In Ex.8-18, a 7685 kVA, 0.8 PF leading, 7500 hp synchronous motor is needed\n",
+ " Ex.8-18b shows that a 0.8 PF leading, 7500 hp synchronous motor must be physically larger than a unity PF, 7500 hp synchronous motor because of its higher kVA rating\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.19, Page number 259"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA_load = 500.0 #Load(kVA)\n",
+ "PF_load = 0.65 #Lagging PF of load\n",
+ "hp = 200.0 #Power rating of the system(hp)\n",
+ "n = 0.88 #Efficiency of the system after adding the load\n",
+ "PF_final = 0.85 #Final lagging PF after adding the load\n",
+ "\n",
+ "#Calculation\n",
+ "kW_original = kVA_load*PF_load #Original kW\n",
+ "sin_theta_load = (1-PF_load**2)**0.5 #Sin\u03b8\n",
+ "kvar_original = kVA_load*sin_theta_load #Original kvar\n",
+ "kW_SM = hp*746/(1000*n) #Synchronous motor kW\n",
+ "#Case(a)\n",
+ "kW_final = kW_original+kW_SM #Final kW of the system with the motor added\n",
+ "kVA_final = kW_final/PF_final #Final kVA of the system with the motor added\n",
+ "PF_system = kW_final/kVA_final #Final PF of the system with the motor added\n",
+ "sin_theta_system = (1-PF_final**2)**0.5 #Sin\u03b8\n",
+ "kvar_final = kVA_final*sin_theta_system #Final kvar of the system with the motor added\n",
+ "#Case(b)\n",
+ "kvar_SM = kvar_final-kvar_original #kvar rating of the synchronous motor\n",
+ "kVA_SM = complex(kW_SM,kvar_SM) #kVA rating of the synchronous motor\n",
+ "kVA_SM_a = cmath.phase(kVA_SM)*180/math.pi #Angle of kVA rating of the synchronous motor(degree)\n",
+ "PF_SM = math.cos(kVA_SM_a*math.pi/180) #PF of the sychronous motor\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): kVA of the system with the motor added , Final kVA = %.f kVA' %kVA_final)\n",
+ "print(' PF of the system with the motor added , System PF = %.2f lagging' %PF_system)\n",
+ "print('Case(b): kVA of the synchronous motor , Synchronous motor kVa = %.f\u2220%.1f\u00b0 kVA' %(abs(kVA_SM),kVA_SM_a))\n",
+ "print(' PF of the synchronous motor at which it operates , Synchronous motor PF = %.3f leading' %PF_SM)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): kVA of the system with the motor added , Final kVA = 582 kVA\n",
+ " PF of the system with the motor added , System PF = 0.85 lagging\n",
+ "Case(b): kVA of the synchronous motor , Synchronous motor kVa = 185\u2220-23.4\u00b0 kVA\n",
+ " PF of the synchronous motor at which it operates , Synchronous motor PF = 0.918 leading\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.20, Page number 261"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "f_m = 60.0 #Frequency of motor(Hz)\n",
+ "f_a = 4000.0 #Frequency of alternator(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "Pole_ratio = f_a/f_m #Ratio of number of poles in alternator to that of motor\n",
+ "P_a = 20.0\n",
+ "P_m = 3.0\n",
+ "P_a1 = 2*P_a #First combination must have 40 poles on the alternator\n",
+ "P_m1 = 2*P_m #First combination must have 6 poles on the synchronous motor\n",
+ "S_1 = 120*f_m/P_m1 #Speed of motor and alternator(rpm)\n",
+ "P_a2 = 4*P_a #Second combination must have 40 poles on the alternator\n",
+ "P_m2 = 4*P_m #Second combination must have 6 poles on the synchronous motor\n",
+ "S_2 = 120*f_m/P_m2 #Speed of motor and alternator(rpm)\n",
+ "P_a3 = 6*P_a #Third combination must have 40 poles on the alternator\n",
+ "P_m3 = 6*P_m #Third combination must have 6 poles on the synchronous motor\n",
+ "S_3 = 120*f_m/P_m3 #Speed of motor and alternator(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('First combination have %.f poles on the alternator and %.f poles on the synchronous motor at a speed %.f rpm' %(P_a1,P_m1,S_1))\n",
+ "print('Second combination have %.f poles on the alternator and %.f poles on the synchronous motor at a speed %.f rpm' %(P_a2,P_m2,S_2))\n",
+ "print('Third combination have %.f poles on the alternator and %.f poles on the synchronous motor at a speed %.f rpm' %(P_a3,P_m3,S_3))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "First combination have 40 poles on the alternator and 6 poles on the synchronous motor at a speed 1200 rpm\n",
+ "Second combination have 80 poles on the alternator and 12 poles on the synchronous motor at a speed 600 rpm\n",
+ "Third combination have 120 poles on the alternator and 18 poles on the synchronous motor at a speed 400 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_9.ipynb b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_9.ipynb new file mode 100755 index 00000000..282faf96 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/CHAP_9.ipynb @@ -0,0 +1,1133 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 9: POLYPHASE INDUCTION(ASYNCHRONOUS) DYNAMOS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.1, Page number 281"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "phase = 3.0 #Number of phases\n",
+ "n = 3.0 #Slots per pole per phase\n",
+ "f = 60.0 #Line frequency(Hz)\n",
+ "f_c = 50.0 #Changed line frequency(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "P = 2*n #Number of poles produced\n",
+ "Total_slots = n*P*phase #Total number of slots on the stator\n",
+ "S_b = 120*f/P #Speed of the rotating magnetic field or poles(rpm)\n",
+ "S_c = 120*f_c/P #Speed of the rotating magnetic field(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Number of poles produced , P = %.f poles' %P)\n",
+ "print(' Total number of slots on the stator , Total slots = %.f slots' %Total_slots)\n",
+ "print('Case(b): Speed of the rotating magnetic fields or poles , S = %.f rpm' %S_b)\n",
+ "print('Case(c): Speed of the rotating magnetic field , S = %.f rpm' %S_c)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Number of poles produced , P = 6 poles\n",
+ " Total number of slots on the stator , Total slots = 54 slots\n",
+ "Case(b): Speed of the rotating magnetic fields or poles , S = 1200 rpm\n",
+ "Case(c): Speed of the rotating magnetic field , S = 1000 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.2, Page number 281"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "s_a = 0.05 #Slip\n",
+ "f_a = 60.0 #Line frequency(Hz)\n",
+ "S_a = 1200.0 #Speed of the rotating magnetic field(rpm)\n",
+ "s_b = 0.07 #Slip\n",
+ "f_b = 50.0 #Line frequency(Hz)\n",
+ "S_b = 1000.0 #Speed of the rotating magnetic field(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "S_r_a = S_a*(1-s_a) #Full-load rotor speed(rpm)\n",
+ "S_r_b = S_b*(1-s_b) #Full-load rotor speed(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full-load rotor speed if slip is 5 percent slip when the frequency is 60 Hz , S_r = %.f rpm' %S_r_a)\n",
+ "print('Case(b): Full-load rotor speed if slip is 7 percent slip when the frequency is 50 Hz , S_r = %.f rpm' %S_r_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full-load rotor speed if slip is 5 percent slip when the frequency is 60 Hz , S_r = 1140 rpm\n",
+ "Case(b): Full-load rotor speed if slip is 7 percent slip when the frequency is 50 Hz , S_r = 930 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.3, Page number 283"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 4.0 #Number of poles in Induction motor\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "s_f = 0.05 #Full-load rotor slip\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "s = 1.0 #Slip = 1 at the instant of starting, since S_r = 0\n",
+ "f_r_a = s*f #Rotor frequency in Hz at the instant of starting\n",
+ "#Case(b)\n",
+ "f_r_b = s_f*f #Full-load rotor frequency in Hz\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rotor frequency at the instant of starting , f_r = %.f Hz' %f_r_a)\n",
+ "print('Case(b): Rotor frequency at full load , f_r = %.f Hz' %f_r_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rotor frequency at the instant of starting , f_r = 60 Hz\n",
+ "Case(b): Rotor frequency at full load , f_r = 3 Hz\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.4, Page number 286"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 4.0 #Number of poles in the induction motor\n",
+ "hp = 50.0 #Rating of the induction motor(hp)\n",
+ "V_o = 208.0 #Voltage rating of the induction motor(V)\n",
+ "T_orig = 225.0 #Starting torque(lb-ft)\n",
+ "I_orig = 700.0 #Instantaneous starting current at rated voltage(A)\n",
+ "V_s = 120.0 #Reduced 3-phase voltage supplied(V)\n",
+ "\n",
+ "#Calculation\n",
+ "T_s = T_orig*(V_s/V_o)**2 #Starting torque(lb-ft)\n",
+ "I_s = I_orig*(V_s/V_o) #Starting current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Starting torque , T_s = %.f lb-ft' %T_s)\n",
+ "print('Case(b): Starting current , I_s = %d A' %I_s)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Starting torque , T_s = 75 lb-ft\n",
+ "Case(b): Starting current , I_s = 403 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.5, Page number 288"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 8.0 #Number of poles in the motor\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "R_r = 0.3 #Rotor resistance per phase(ohm)\n",
+ "S_r = 650.0 #Speed at which motor stalls(rpm)\n",
+ "s = 0.05 #Rated slip\n",
+ "\n",
+ "#Calculation\n",
+ "S = 120*f/P #Speed of the rotating magnetic field(rpm)\n",
+ "s_b = (S-S_r)/S #Breakdown Slip\n",
+ "X_lr = R_r/s_b #Locked rotor reactance(ohm)\n",
+ "f_r = s_b*f #Rotor frequency at the maximum torque point(Hz)\n",
+ "S_r = S*(1-s) #Full-load speed at rated slip(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Breakdown slip , s_b = %.3f' %s_b)\n",
+ "print('Case(b): Locked-rotor reactance , X_lr = %.2f \u03a9' %X_lr)\n",
+ "print('Case(c): Rotor frequency at the maximum torque point , f_r = %.1f Hz' %f_r)\n",
+ "print('Case(d): Full-load speed if the rated slip is 5 percent , S_r = %.f rpm' %S_r)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Breakdown slip , s_b = 0.278\n",
+ "Case(b): Locked-rotor reactance , X_lr = 1.08 \u03a9\n",
+ "Case(c): Rotor frequency at the maximum torque point , f_r = 16.7 Hz\n",
+ "Case(d): Full-load speed if the rated slip is 5 percent , S_r = 855 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.6, Page number 295"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 8.0 #Number of poles in the motor\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "R_r = 0.3 #Rotor resistance per phase(ohm/phase)\n",
+ "R_x = 0.7 #Added resistance(ohm/phase)\n",
+ "S_r = 875.0 #Full-load Speed(rpm) \n",
+ "S = 900.0 #Speed of the rotating magnetic field(rpm)\n",
+ "X_lr = 1.08 #Locked rotor reactance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "s = (S-S_r)/S #Full-load slip,short circuited\n",
+ "R_r_total = R_r+R_x #Total resistance per phase(ohm)\n",
+ "s_r = R_r_total/R_r*s #New full-load slip with added resistance\n",
+ "S_r_new = S*(1-s_r) #New full-load speed(rpm) \n",
+ "#Case(b)\n",
+ "T_o = R_r/(R_r**2+X_lr**2) #Original torque\n",
+ "T_f = (R_r+R_x)/((R_r+R_x)**2+X_lr**2) #New torque\n",
+ "torque_ratio = T_f/T_o #Ratio of final torque to original torque\n",
+ "T_final = 2*torque_ratio\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): New full-load speed with added resistance , S(1-s) = %.f rpm' %S_r_new)\n",
+ "print('Case(b): Starting torque with added resistance , T_f = %.2f*T_fl' %T_final)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): New full-load speed with added resistance , S(1-s) = 817 rpm\n",
+ "Case(b): Starting torque with added resistance , T_f = 3.87*T_fl\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.7, Page number 295"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 8.0 #Number of poles in the motor\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "R_r = 0.3 #Rotor resistance per phase(ohm/phase)\n",
+ "R_x = 0.7 #Added resistance(ohm/phase)\n",
+ "X_lr = 1.08 #Locked rotor reactance(ohm)\n",
+ "E_lr = 112.0 #Induced voltage per phase(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "Z_lr = complex(R_r,X_lr) #Locked rotor impedance per phase(ohm)\n",
+ "I_r = E_lr/abs(Z_lr) #Rotor current per phase(A)\n",
+ "angle_Z_lr = cmath.phase(Z_lr)*180/math.pi #Angle of locked rotor impedance per phase(degree)\n",
+ "PF = math.cos(angle_Z_lr*math.pi/180) #PF with rotor short circuited\n",
+ "PF_a = R_r/abs(Z_lr) #PF with rotor short circuited\n",
+ "#Case(b)\n",
+ "Z_lr_b = complex(R_r+R_x,X_lr) #Locked rotor impedance per phase with added resistance(ohm)\n",
+ "I_r_b = E_lr/abs(Z_lr_b) #Rotor current per phase with added resistance(A)\n",
+ "angle_Z_lr_b = cmath.phase(Z_lr_b)*180/math.pi #Angle of locked rotor impedance per phase with added resistance(degree)\n",
+ "PF_2 = math.cos(angle_Z_lr_b*math.pi/180) #PF with added resistance\n",
+ "PF_b = (R_r+R_x)/abs(Z_lr_b) #PF with added resistance\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rotor current per phase with rotor short-circuited , I_r = %.fA' %I_r)\n",
+ "print(' Power factor with rotor short-circuited , cos\u03b8 = %.3f ' %PF)\n",
+ "print('Case(b): Rotor current per phase with added resistance , I_r = %.1f A' %I_r_b)\n",
+ "print(' Power factor with added resistance , cos\u03b8_r = %.2f ' %PF_2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rotor current per phase with rotor short-circuited , I_r = 100A\n",
+ " Power factor with rotor short-circuited , cos\u03b8 = 0.268 \n",
+ "Case(b): Rotor current per phase with added resistance , I_r = 76.1 A\n",
+ " Power factor with added resistance , cos\u03b8_r = 0.68 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.8, Page number 296"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 8.0 #Number of poles in the motor\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "R_r = 0.3 #Rotor resistance per phase(ohm/phase)\n",
+ "R_x = 0.7 #Added resistance(ohm/phase)\n",
+ "X_lr = 1.08 #Locked rotor reactance(ohm)\n",
+ "E_lr = 112.0 #Induced voltage per phase(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "T_o = R_r/(R_r**2+X_lr**2) #Original torque\n",
+ "a = 0.24 #Co-efficient of x^2\n",
+ "b = -0.856 #Co-efficient of x\n",
+ "c = 0 #Constant\n",
+ "sol_1 = (-b+(b**2-4*a*c)**0.5)/(2*a) #Solution 1\n",
+ "sol_2 = (-b-(b**2-4*a*c)**0.5)/(2*a) #Solution 1\n",
+ "R_x = sol_1\n",
+ "R_x2 = sol_2\n",
+ "R_T = R_r+R_x #Added rotor resistance(ohm)\n",
+ "#Case(b)\n",
+ "Z_T = complex(R_T,X_lr) #Impedance(ohm)\n",
+ "angle_Z_T = cmath.phase(Z_T)*180/math.pi #Angle of impedance(degree)\n",
+ "PF = math.cos(angle_Z_T*math.pi/180) #Rotor PF\n",
+ "PF_b = R_T/abs(Z_T) #Rotor PF\n",
+ "#Case(c)\n",
+ "I_r = E_lr/abs(Z_T) #Starting current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Added rotor resistance , R_T = %.2f \u03a9' %R_T)\n",
+ "print('Case(b): Rotor power factor that will produce same starting torque , cos\u03b8 = %.3f ' %PF)\n",
+ "print('Case(c): Starting current , I_r = %.f A' %I_r)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Added rotor resistance , R_T = 3.87 \u03a9\n",
+ "Case(b): Rotor power factor that will produce same starting torque , cos\u03b8 = 0.963 \n",
+ "Case(c): Starting current , I_r = 28 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.9, Page number 297"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 8.0 #Number of poles in the motor\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "R_r = 0.3 #Rotor resistance(ohm)\n",
+ "S_r = 875.0 #Full-load Speed(rpm)\n",
+ "R_x_a = 1.7 #Added rotor resistance(ohm)\n",
+ "R_x_b = 2.7 #Added rotor resistance(ohm)\n",
+ "R_x_c = 3.7 #Added rotor resistance(ohm)\n",
+ "R_x_d = 4.7 #Added rotor resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "S_o = 120*f/P #Speed of the rotating magnetic field(rpm)\n",
+ "s_o = (S_o-S_r)/S_o #Full-load slip\n",
+ "s_r_a = s_o*(R_r+R_x_a)/R_r #Slip\n",
+ "S_r_a = S_o*(1-s_r_a) #Rotor speed(rpm)\n",
+ "s_r_b = s_o*(R_r+R_x_b)/R_r #Slip\n",
+ "S_r_b = S_o*(1-s_r_b) #Rotor speed(rpm)\n",
+ "s_r_c = s_o*(R_r+R_x_c)/R_r #Slip\n",
+ "S_r_c = S_o*(1-s_r_c) #Rotor speed(rpm)\n",
+ "s_r_d = s_o*(R_r+R_x_d)/R_r #Slip\n",
+ "S_r_d = S_o*(1-s_r_d) #Rotor speed(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full load speed for added rotor resistance of 1.7 \u03a9 , S_r = %.1f rpm' %S_r_a)\n",
+ "print('Case(b): Full load speed for added rotor resistance of 2.7 \u03a9 , S_r = %.f rpm' %S_r_b)\n",
+ "print('Case(c): Full load speed for added rotor resistance of 3.7 \u03a9 , S_r = %d rpm' %S_r_c)\n",
+ "print('Case(d): Full load speed for added rotor resistance of 4.7 \u03a9 , S_r = %.f rpm' %S_r_d)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full load speed for added rotor resistance of 1.7 \u03a9 , S_r = 733.3 rpm\n",
+ "Case(b): Full load speed for added rotor resistance of 2.7 \u03a9 , S_r = 650 rpm\n",
+ "Case(c): Full load speed for added rotor resistance of 3.7 \u03a9 , S_r = 566 rpm\n",
+ "Case(d): Full load speed for added rotor resistance of 4.7 \u03a9 , S_r = 483 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.10, Page number 302"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 4.0 #Number of poles in WRIM\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "V = 220.0 #Line voltage(V)\n",
+ "hp = 1.0 #Power rating of WRIM(hp)\n",
+ "S_r = 1740.0 #Full-load rated speed(rpm)\n",
+ "R_r = 0.3 #Rotor resistance(ohm)\n",
+ "X_lr = 1.0 #Locked rotor reactance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_p = V #Phase voltage(V)\n",
+ "E_lr = V_p/4 #Locked-rotor voltage per phase(V)\n",
+ "#Case(b)\n",
+ "S = 120*f/P #Speed of the rotating magnetic field(rpm)\n",
+ "s = (S-S_r)/S #Slip\n",
+ "I_r = E_lr/((R_r/s)**2+X_lr**2)**0.5 #Rotor current per phase at rated speed(A/phase)\n",
+ "#Case(c)\n",
+ "P_in = I_r**2*R_r/s #Rated rotor power input per phase(W/phase)\n",
+ "#Case(d)\n",
+ "P_RL = I_r**2*R_r #Rated rotor copper loss per phase(W/phase)\n",
+ "#Case(e)\n",
+ "P_d = P_in-P_RL #Rotor power developed per phase(W)\n",
+ "P_d_hp = P_d/746 #Rotor power developed per phase(hp)\n",
+ "#Case(f)\n",
+ "T_d = P_d_hp*5252/S_r #Rotor torque developed per phase(lb-ft)\n",
+ "T_d2 = 7.04*P_in/S #Rotor torque developed per phase(lb-ft)\n",
+ "T_dm = 3*T_d #Total rotor torque(lb-ft)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Locked-rotor voltage per phase , E_lr = %.f V' %E_lr)\n",
+ "print('Case(b): Rotor current per phase at rated speed , I_r = %.3f A/phase' %I_r)\n",
+ "print('Case(c): Rated rotor power input per phase , P_in = %.f W/phase' %P_in)\n",
+ "print('Case(d): Rated rotor copper loss per phase , P_RL = %.2f W' %P_RL)\n",
+ "print('Case(e): Rotor power developed per phase , P_d = %.1f W/phase' %P_d)\n",
+ "print(' Rotor power developed per phase , P_d = %.2f hp/phase' %P_d_hp)\n",
+ "print('Case(f): Rotor torque developed per phase by method 1 , T_d = %.1f lb-ft' %T_d)\n",
+ "print(' Rotor torque developed per phase by method 2 , T_d = %.1f lb-ft' %T_d2)\n",
+ "print(' Total rotor torque , T_dm = %.1f lb-ft' %T_dm)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Locked-rotor voltage per phase , E_lr = 55 V\n",
+ "Case(b): Rotor current per phase at rated speed , I_r = 6.074 A/phase\n",
+ "Case(c): Rated rotor power input per phase , P_in = 332 W/phase\n",
+ "Case(d): Rated rotor copper loss per phase , P_RL = 11.07 W\n",
+ "Case(e): Rotor power developed per phase , P_d = 320.9 W/phase\n",
+ " Rotor power developed per phase , P_d = 0.43 hp/phase\n",
+ "Case(f): Rotor torque developed per phase by method 1 , T_d = 1.3 lb-ft\n",
+ " Rotor torque developed per phase by method 2 , T_d = 1.3 lb-ft\n",
+ " Total rotor torque , T_dm = 3.9 lb-ft\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.11, Page number 303"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 6.0 #Number of poles in WRIM\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "V = 208.0 #Line voltage(V)\n",
+ "hp = 7.5 #Power rating of WRIM(hp)\n",
+ "S_r = 1125.0 #Full-load rated speed(rpm)\n",
+ "R_r = 0.08 #Rotor resistance(ohm/phase)\n",
+ "X_lr = 0.4 #Locked rotor reactance(ohm/phase)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_p = V/3**0.5 #Phase voltage(V)\n",
+ "E_lr = V_p/2 #Locked-rotor voltage per phase(V)\n",
+ "#Case(b)\n",
+ "S = 120*f/P #Speed of the rotating magnetic field(rpm)\n",
+ "s = (S-S_r)/S #Slip\n",
+ "I_r = E_lr/((R_r/s)**2+X_lr**2)**0.5 #Rotor current per phase at rated speed(A/phase)\n",
+ "#Case(c)\n",
+ "P_in = I_r**2*R_r/s #Rated rotor power input per phase(W/phase)\n",
+ "#Case(d)\n",
+ "P_RL = I_r**2*R_r #Rated rotor copper loss per phase(W/phase)\n",
+ "#Case(e)\n",
+ "P_d = P_in-P_RL #Rotor power developed per phase(W)\n",
+ "P_d_hp = P_d/746 #Rotor power developed per phase(hp)\n",
+ "#Case(f)\n",
+ "T_d = P_d_hp*5252/S_r #Rotor torque developed per phase(lb-ft)\n",
+ "T_d2 = 7.04*P_in/S #Rotor torque developed per phase(lb-ft)\n",
+ "#Case(g)\n",
+ "T_dm = 3*T_d #Total rotor torque(lb-ft)\n",
+ "#Case(h)\n",
+ "P_o = hp*746 #Output power(W)\n",
+ "T_o = 7.04*P_o/S_r #Total output rotor torque(lb-ft)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Locked-rotor voltage per phase , E_lr = %.f V' %E_lr)\n",
+ "print('Case(b): Rotor current per phase at rated speed , I_r = %.2f A/phase' %I_r)\n",
+ "print('Case(c): Rated rotor power input per phase , P_in = %.f W/phase' %P_in)\n",
+ "print('Case(d): Rated rotor copper loss per phase , P_RL = %.1f W/phase' %P_RL)\n",
+ "print('Case(e): Rotor power developed per phase , P_d = %.f W/phase' %P_d)\n",
+ "print(' Rotor power developed per phase , P_d = %.2f hp/phase' %P_d_hp)\n",
+ "print('Case(f): Rotor torque developed per phase by method 1 , T_d = %.1f lb-ft/phase' %T_d)\n",
+ "print(' Rotor torque developed per phase by method 2 , T_d = %.1f lb-ft/phase' %T_d2)\n",
+ "print('Case(g): Total rotor torque , T_dm = %.f lb-ft' %T_dm)\n",
+ "print('Case(h): Total output rotor torque , T_o = %.f lb-ft' %T_o)\n",
+ "print('\\nNOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Locked-rotor voltage per phase , E_lr = 60 V\n",
+ "Case(b): Rotor current per phase at rated speed , I_r = 44.77 A/phase\n",
+ "Case(c): Rated rotor power input per phase , P_in = 2566 W/phase\n",
+ "Case(d): Rated rotor copper loss per phase , P_RL = 160.4 W/phase\n",
+ "Case(e): Rotor power developed per phase , P_d = 2406 W/phase\n",
+ " Rotor power developed per phase , P_d = 3.22 hp/phase\n",
+ "Case(f): Rotor torque developed per phase by method 1 , T_d = 15.1 lb-ft/phase\n",
+ " Rotor torque developed per phase by method 2 , T_d = 15.1 lb-ft/phase\n",
+ "Case(g): Total rotor torque , T_dm = 45 lb-ft\n",
+ "Case(h): Total output rotor torque , T_o = 35 lb-ft\n",
+ "\n",
+ "NOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.12, Page number 304"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 4.0 #Number of poles in WRIM\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "V = 220.0 #Line voltage(V)\n",
+ "hp = 1.0 #Power rating of WRIM(hp)\n",
+ "R_r = 0.3 #Rotor resistance(ohm)\n",
+ "X_lr = 1.0 #Locked rotor reactance(ohm)\n",
+ "n = 3.0 #Number of phases\n",
+ "\n",
+ "#Calculation\n",
+ "V_p = V #Phase voltage(V)\n",
+ "E_lr = V_p/4 #Locked-rotor voltage per phase(V)\n",
+ "P_in = E_lr**2/(2*X_lr)*n #Total 3-phase rotor power input(W)\n",
+ "S = 120*f/P #Speed of the rotating magnetic field(rpm)\n",
+ "T_max = 7.04*P_in/S #Maximum torque developed(lb-ft)\n",
+ "s_b = R_r/X_lr #Slip\n",
+ "S_r = S*(1-s_b) #Speed at which maximum torque is developed(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('Maximum torque developed , T_max = %.2f lb-ft' %T_max)\n",
+ "print('Percent slip , s_b = %.f percent' %(s_b*100))\n",
+ "print('Speed at which maximum torque is developed , S_r = %.f rpm' %S_r)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Maximum torque developed , T_max = 17.75 lb-ft\n",
+ "Percent slip , s_b = 30 percent\n",
+ "Speed at which maximum torque is developed , S_r = 1260 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.13, Page number 304"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 4.0 #Number of poles in WRIM\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "V = 220.0 #Line voltage(V)\n",
+ "hp = 1.0 #Power rating of WRIM(hp)\n",
+ "R_r = 0.3 #Rotor resistance(ohm)\n",
+ "X_lr = 1.0 #Locked rotor reactance(ohm)\n",
+ "n = 3.0 #Number of phases\n",
+ "\n",
+ "#Calculation\n",
+ "V_p = V #Phase voltage(V)\n",
+ "E_lr = V_p/4 #Locked-rotor voltage per phase(V)\n",
+ "P_in = n*(E_lr**2/(R_r**2+X_lr**2))*R_r #Total 3-phase rotor power input(W)\n",
+ "S = 120*f/P #Speed of the rotating magnetic field(rpm)\n",
+ "T_s = 7.04*P_in/S #Starting torque developed(lb-ft)\n",
+ "\n",
+ "#Result\n",
+ "print('Starting torque developed , T_s = %.2f lb-ft' %T_s)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Starting torque developed , T_s = 9.77 lb-ft\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.14, Page number 306"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "T_max = 17.75 #Maximum torque developed(lb-ft)\n",
+ "s_max = 0.3 #Slip for which T_max occurs\n",
+ "s_a = 0.0333 #Slip\n",
+ "s_b = 1.0 #Slip \n",
+ "\n",
+ "#Calculation\n",
+ "T_a = T_max*(2/((s_max/s_a)+(s_a/s_max))) #Full-load torque(lb-ft)\n",
+ "T_b = T_max*(2/((s_max/s_b)+(s_b/s_max))); #Starting torque(lb-ft)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full-load torque at a slip of 0.0333 , T = %.1f lb-ft' %T_a)\n",
+ "print('Case(b): Starting torque at a slip of 1.0 , T = %.2f lb-ft' %T_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full-load torque at a slip of 0.0333 , T = 3.9 lb-ft\n",
+ "Case(b): Starting torque at a slip of 1.0 , T = 9.77 lb-ft\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.15, Page number 307"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "import numpy\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 4.0 #Number of poles in SCIM \n",
+ "S_r = 1746.0 #Rated rotor speed(rpm)\n",
+ "V = 220.0 #Voltage rating of SCIM(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "P_hp = 10.0 #Power rating of SCIM(hp)\n",
+ "R_a = 0.4 #Armature resistance(ohm)\n",
+ "R_r = 0.14 #Rotor resistance(ohm)\n",
+ "jXm = 16.0 #Reactance(ohm)\n",
+ "jXs = 0.35 #Synchronous reactance(ohm)\n",
+ "jXlr = 0.35 #Locked rotor reactance(ohm)\n",
+ "P_r_total = 360.0 #Total rotational losses(W)\n",
+ "\n",
+ "#Calculation\n",
+ "V_p = V/3**0.5 #Voltage per phase(V)\n",
+ "S = 120*f/P #Speed of the rotating magnetic field(rpm)\n",
+ "s = (S-S_r)/S #Slip\n",
+ "I1_1 = complex(R_a,jXm+jXs)\n",
+ "I1_2 = complex(0,-jXm)\n",
+ "I2_1 = complex(0,-jXm)\n",
+ "I2_2 = complex(R_r/s,jXm+jXlr)\n",
+ "V_1 = V_p\n",
+ "V_2 = 0\n",
+ "A = [[I1_1,I2_1],[I1_2,I2_2]] #Matrix containing above mesh eqns array\n",
+ "delta = numpy.linalg.det(A) #Determinant of A\n",
+ "#Case(a)\n",
+ "I_p = numpy.linalg.det([[V_1,I2_1],[V_2,I2_2]])/delta #Stator armature current(A)\n",
+ "I_1 = I_p\n",
+ "#Case(b)\n",
+ "I_r = numpy.linalg.det([[I1_1,V_1],[I1_2,V_2]])/delta #Rotor armature current(A)\n",
+ "I_2 = I_r\n",
+ "#Case(c)\n",
+ "theta_1 = cmath.phase(I_p)*180/math.pi #Motor PF angle(degrees)\n",
+ "cos_theta1 = math.cos(theta_1*math.pi/180) #Motor PF\n",
+ "#Case(d)\n",
+ "SPI = V_p*abs(I_p)*cos_theta1 #Stator power input(W)\n",
+ "#Case(e)\n",
+ "SCL = abs(I_p)**2 *R_a #Stator Copper Loss(W)\n",
+ "#Case(f)\n",
+ "RPI = SPI-SCL #Rotor power input(W) Method 1\n",
+ "RPI_2 = abs(I_r)**2*(R_r/s) #Rotor power input(W) Method 2\n",
+ "#Case(g)\n",
+ "RPD = RPI*(1-s) #Rotor power developed(W) Method 1\n",
+ "RCL = s*RPI #Rotor copper losses(W)\n",
+ "RPD_2 = RPI-RCL #Rotor power developed(W) Method 2\n",
+ "RPD_3 = abs(I_r)**2*R_r*(1-s)/s #Rotor power developed(W) Method 3\n",
+ "#Case(h)\n",
+ "P_r = P_r_total/3 #Rotational losses per phase(W)\n",
+ "P_o = RPD-P_r #Rotor power per phase(W)\n",
+ "P_to = 3.0*P_o #Total rotor power at the motor pulley(W)\n",
+ "#Case(i)\n",
+ "T = 7.04*(P_to/S_r) #Total 3-phase torque(lb-ft)\n",
+ "#Case(j)\n",
+ "P_t = P_to \n",
+ "hp = P_t/746.0 #Output horsepower(hp)\n",
+ "#Case(k)\n",
+ "P_in = SPI #Input power to stator(W)\n",
+ "n = P_o/P_in*100 #Motor efficiency at rated load(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Stator armature current , I_p = %.2f\u2220%.2f\u00b0 A (lagging)' %(abs(I_p),cmath.phase(I_p)*180/math.pi))\n",
+ "print('Case(b): Rotor current per phase , I_r = %.3f\u2220%.2f\u00b0 A (lagging)' %(abs(I_r),cmath.phase(I_r)*180/math.pi))\n",
+ "print('Case(c): Motor power factor , cos \u04e8_1 = %.4f' %cos_theta1)\n",
+ "print('Case(d): Stator power input , SPI = %d W' %SPI)\n",
+ "print('Case(e): Stator copper loss , SCL = %d W' %SCL)\n",
+ "print('Case(f): Rotor power input , RPI = %d W (Method 1)' %RPI)\n",
+ "print(' Rotor power input , RPI = %d W (Method 2)' %RPI_2)\n",
+ "print('Case(g): Rotor power developed , RPD = %d W (Method 1)' %RPD)\n",
+ "print(' Rotor power developed , RPD = %d W (Method 2)' %RPD_2)\n",
+ "print(' Rotor power developed , RPD = %d W (Method 3)' %RPD_3)\n",
+ "print('Case(h): Total rotor power at the motor pulley , P_to = %d W' %P_to)\n",
+ "print('Case(i): Total three-phase output torque , T = %d lb-ft' %T)\n",
+ "print('Case(j): Output horsepower , hp = %.1f hp' %hp)\n",
+ "print('Case(k): Motor efficiency at rated load , \u03b7 = %.1f percent' %n)\n",
+ "print('\\nNOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Stator armature current , I_p = 25.90\u2220-22.44\u00b0 A (lagging)\n",
+ "Case(b): Rotor current per phase , I_r = 24.374\u2220-6.51\u00b0 A (lagging)\n",
+ "Case(c): Motor power factor , cos \u04e8_1 = 0.9243\n",
+ "Case(d): Stator power input , SPI = 3040 W\n",
+ "Case(e): Stator copper loss , SCL = 268 W\n",
+ "Case(f): Rotor power input , RPI = 2772 W (Method 1)\n",
+ " Rotor power input , RPI = 2772 W (Method 2)\n",
+ "Case(g): Rotor power developed , RPD = 2689 W (Method 1)\n",
+ " Rotor power developed , RPD = 2689 W (Method 2)\n",
+ " Rotor power developed , RPD = 2689 W (Method 3)\n",
+ "Case(h): Total rotor power at the motor pulley , P_to = 7707 W\n",
+ "Case(i): Total three-phase output torque , T = 31 lb-ft\n",
+ "Case(j): Output horsepower , hp = 10.3 hp\n",
+ "Case(k): Motor efficiency at rated load , \u03b7 = 84.5 percent\n",
+ "\n",
+ "NOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.16, Page number 313"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 208.0 #Rated voltage(V)\n",
+ "P_o = 15.0 #Rated power(hp)\n",
+ "I = 42.0 #Rated current(A)\n",
+ "I_st = 252.0 #Starting current(A)\n",
+ "T_st = 120.0 #Full-voltage starting torque(lb-ft)\n",
+ "tap = 0.6 #Tapping employed by compensator\n",
+ "\n",
+ "#Calculation\n",
+ "I_sm = tap*I_st #Motor starting current at reduced voltage(A) \n",
+ "I_L = tap*I_sm #Motor line current(A)\n",
+ "T_s = tap**2*T_st #Motor starting torque at reduced voltage(lb-ft)\n",
+ "percent_I_L = I_L/I_st*100 #Percent line current at starting\n",
+ "percent_T_st = T_s/T_st*100 #Percent motor starting torque\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Motor starting current at reduced voltage , I_sm = %.1f A to the motor' %I_sm)\n",
+ "print('Case(b): Motor line current neglecting tarnsformer exciting current and losses , I_L = %.2f A drawn from the mains' %I_L)\n",
+ "print('Case(c): Motor starting torque at reduced voltage , T_s = %.1f lb-ft' %T_s)\n",
+ "print('Case(d): Percent line current at starting = %.f percent of line current at full voltage' %percent_I_L)\n",
+ "print('Case(e): Percent motor starting torque = %.f percent of starting torque at full voltage' %percent_T_st)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Motor starting current at reduced voltage , I_sm = 151.2 A to the motor\n",
+ "Case(b): Motor line current neglecting tarnsformer exciting current and losses , I_L = 90.72 A drawn from the mains\n",
+ "Case(c): Motor starting torque at reduced voltage , T_s = 43.2 lb-ft\n",
+ "Case(d): Percent line current at starting = 36 percent of line current at full voltage\n",
+ "Case(e): Percent motor starting torque = 36 percent of starting torque at full voltage\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.17, Page number 324"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_o = 220.0 #Rated voltage(V)\n",
+ "P = 4.0 #Number of poles in SCIM\n",
+ "P_o = 10.0 #Rated power(hp)\n",
+ "T_o = 30.0 #Rated torque(lb-ft)\n",
+ "S_r = 1710.0 #Rated rotor speed(rpm)\n",
+ "V_n1 = 242.0 #Impressed stator voltage(V) Case(a)\n",
+ "V_n2 = 198.0 #Impressed stator voltage(V) Case(b)\n",
+ "f = 60.0 #Frequency(Hz) assumption\n",
+ "\n",
+ "#Calculation\n",
+ "S = (120*f)/P #Speed of the rotating magnetic field(rpm)\n",
+ "s_o = (S-S_r)/S #Rated slip\n",
+ "#Case(a)\n",
+ "T_n1 = T_o*(V_n1/V_o)**2 #New torque(lb-ft)\n",
+ "s_n1 = s_o*(T_o/T_n1) #New slip\n",
+ "S_rn1 = S*(1-s_n1) #New speed(rpm)\n",
+ "#Case(b)\n",
+ "T_n2 = T_o*(V_n2/V_o)**2 #New torque(lb-ft)\n",
+ "s_n2 = s_o*(T_o/T_n2) #New slip\n",
+ "S_rn2 = S*(1-s_n2) #New speed(rpm)\n",
+ "#Case(c)\n",
+ "percent_slip_a = (s_o-s_n1)/s_o*100 #Percent change in slip in part(a)\n",
+ "percent_speed_a = (S_rn1-S_r)/S_r*100 #Percent change in speed in part(a)\n",
+ "#Case(d)\n",
+ "percent_slip_b = (s_n2-s_o)/s_o*100 #Percent change in slip in part(b)\n",
+ "percent_speed_b = (S_r-S_rn2)/S_r*100 #Percent change in speed in part(b)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): New torque at an impressed stator voltage of 242 V , T_n = %.1f lb-ft' %T_n1)\n",
+ "print(' New slip , s_n = %.4f ' %s_n1)\n",
+ "print(' New speed , S_rn = %.f rpm' %S_rn1)\n",
+ "print('Case(b): New torque at an impressed stator voltage of 198 V , T_n = %.1f lb-ft' %T_n2)\n",
+ "print(' New slip , s_n = %.4f ' %s_n2)\n",
+ "print(' New speed , S_rn = %.f rpm' %S_rn2)\n",
+ "print('Case(c): Percentage change in slip due to voltage change in part a = %.1f percent decrease' %percent_slip_a)\n",
+ "print(' Percentage change in speed = %.2f percent increase' %percent_speed_a)\n",
+ "print('Case(d): Percentage change in slip due to voltage change in part b = %.1f percent increase' %percent_slip_b)\n",
+ "print(' Percentage change in speed = %.2f percent decrease' %percent_speed_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): New torque at an impressed stator voltage of 242 V , T_n = 36.3 lb-ft\n",
+ " New slip , s_n = 0.0413 \n",
+ " New speed , S_rn = 1726 rpm\n",
+ "Case(b): New torque at an impressed stator voltage of 198 V , T_n = 24.3 lb-ft\n",
+ " New slip , s_n = 0.0617 \n",
+ " New speed , S_rn = 1689 rpm\n",
+ "Case(c): Percentage change in slip due to voltage change in part a = 17.4 percent decrease\n",
+ " Percentage change in speed = 0.91 percent increase\n",
+ "Case(d): Percentage change in slip due to voltage change in part b = 23.5 percent increase\n",
+ " Percentage change in speed = 1.23 percent decrease\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.18, Page number 324"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_o = 220.0 #Rated voltage(V)\n",
+ "P = 4.0 #Number of poles in SCIM\n",
+ "P_o = 10.0 #Rated power(hp)\n",
+ "R_ro = 0.3 #Rotor resistance(ohm)\n",
+ "R_re = 1.7 #External rotor resistance(ohm)\n",
+ "T_o = 30.0 #Rated torque(lb-ft)\n",
+ "S_r = 1750.0 #Rated rotor speed(rpm)\n",
+ "V_n1 = 240.0 #Impressed stator voltage(V) Case(a)\n",
+ "V_n2 = 208.0 #Impressed stator voltage(V) Case(b)\n",
+ "V_n3 = 110.0 #Impressed stator voltage(V) Case(c)\n",
+ "f = 60.0 #Frequency(Hz) assumption\n",
+ "\n",
+ "#Calculation\n",
+ "S = (120*f)/P #Speed of the rotating magnetic field(rpm)\n",
+ "s_o = (S-S_r)/S #Rated slip\n",
+ "R_rn = R_ro+R_re #Resistance(ohm)\n",
+ "#Case(a)\n",
+ "T_n1 = T_o*(V_n1/V_o)**2 #New torque(lb-ft)\n",
+ "s_n1 = s_o*(T_o/T_n1)*(R_rn/R_ro) #New slip\n",
+ "S_rn1 = S*(1-s_n1) #New speed(rpm)\n",
+ "#Case(b)\n",
+ "T_n2 = T_o*(V_n2/V_o)**2 #New torque(lb-ft)\n",
+ "s_n2 = s_o*(T_o/T_n2)*(R_rn/R_ro) #New slip\n",
+ "S_rn2 = S*(1-s_n2) #New speed(rpm)\n",
+ "#Case(c)\n",
+ "T_n3 = T_o*(V_n3/V_o)**2 #New torque(lb-ft)\n",
+ "s_n3 = s_o*(T_o/T_n3)*(R_rn/R_ro) #New slip\n",
+ "S_rn3 = S*(1-s_n3) #New speed(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): New torque at an impressed stator voltage of 240 V , T_n = %.1f lb-ft' %T_n1)\n",
+ "print(' New slip , s_n = %.4f ' %s_n1)\n",
+ "print(' New speed , S_rn = %.f rpm' %S_rn1)\n",
+ "print('Case(b): New torque at an impressed stator voltage of 208 V , T_n = %.2f lb-ft' %T_n2)\n",
+ "print(' New slip , s_n = %.3f ' %s_n2)\n",
+ "print(' New speed , S_rn = %.f rpm' %S_rn2)\n",
+ "print('Case(c): New torque at an impressed stator voltage of 110 V , T_n = %.1f lb-ft' %T_n3)\n",
+ "print(' New slip , s_n = %.3f ' %s_n3)\n",
+ "print(' New speed , S_rn = %.f rpm' %S_rn3)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): New torque at an impressed stator voltage of 240 V , T_n = 35.7 lb-ft\n",
+ " New slip , s_n = 0.1556 \n",
+ " New speed , S_rn = 1520 rpm\n",
+ "Case(b): New torque at an impressed stator voltage of 208 V , T_n = 26.82 lb-ft\n",
+ " New slip , s_n = 0.207 \n",
+ " New speed , S_rn = 1427 rpm\n",
+ "Case(c): New torque at an impressed stator voltage of 110 V , T_n = 7.5 lb-ft\n",
+ " New slip , s_n = 0.741 \n",
+ " New speed , S_rn = 467 rpm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.19, Page number 327"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 8.0 #Number of poles in WRIM\n",
+ "f = 60.0 #Operating frequency of the WRIM(Hz)\n",
+ "S_con_a1 = 1800.0 #Speed of the convertor(rpm)\n",
+ "S_con_a2 = 450.0 #Speed of the convertor(rpm)\n",
+ "f_con_b1 = 25.0 #Frequency of an induction converter(Hz)\n",
+ "f_con_b2 = 400.0 #Frequency of an induction converter(Hz)\n",
+ "f_con_b3 = 120.0 #Frequency of an induction converter(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "S = (120*f)/P #Speed of the rotating magnetic field(rpm)\n",
+ "#Case(a)\n",
+ "f_con_a1 = f*(1+S_con_a1/S) #Frequency of an induction converter(Hz)\n",
+ "f_con_a2 = f*(1-S_con_a2/S) #Frequency of an induction converter(Hz)\n",
+ "#Case(b)\n",
+ "S_con_b1 = (-1+f_con_b1/f)*S #Speed of the converter(rpm)\n",
+ "S_con_b2 = (-1+f_con_b2/f)*S #Speed of the converter(rpm)\n",
+ "S_con_b3 = (-1+f_con_b3/f)*S #Speed of the converter(rpm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Frequency , f_con = %.f Hz for %d rpm in opposite direction' %(f_con_a1,S_con_a1))\n",
+ "print(' Frequency , f_con = %.f Hz for %d rpm in same direction' %(f_con_a2,S_con_a2))\n",
+ "print('Case(b)1: Speed and direction to obtain 25 Hz , S_con = %.f rpm, or %.f rpm in same direction' %(S_con_b1,abs(S_con_b1)))\n",
+ "print(' 2: Speed and direction to obtain 400 Hz , S_con = %.f rpm in opposite direction' %S_con_b2)\n",
+ "print(' 3: Speed and direction to obtain 120 Hz , S_con = %.f rpm in opposite direction to rotating stator flux' %S_con_b3)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Frequency , f_con = 180 Hz for 1800 rpm in opposite direction\n",
+ " Frequency , f_con = 30 Hz for 450 rpm in same direction\n",
+ "Case(b)1: Speed and direction to obtain 25 Hz , S_con = -525 rpm, or 525 rpm in same direction\n",
+ " 2: Speed and direction to obtain 400 Hz , S_con = 5100 rpm in opposite direction\n",
+ " 3: Speed and direction to obtain 120 Hz , S_con = 900 rpm in opposite direction to rotating stator flux\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/README.txt b/Electric_Machinery_and_Transformers_by_Irving_Kosow/README.txt new file mode 100755 index 00000000..149b291e --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/README.txt @@ -0,0 +1,10 @@ +Contributed By: KAVAN A B +Course: be +College/Institute/Organization: SRI JAYACHAMARAJENDRA COLLEGE OF ENGINEERING +Department/Designation: ELECTRICAL & ELECTRONICS +Book Title: Electric Machinery and Transformers +Author: Irving Kosow +Publisher: Pearson Education, New Delhi +Year of publication: 2007 +Isbn: 978-81-317-1127-9 +Edition: Second Edition
\ No newline at end of file diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/screenshots/1.png b/Electric_Machinery_and_Transformers_by_Irving_Kosow/screenshots/1.png Binary files differnew file mode 100755 index 00000000..343f548e --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/screenshots/1.png diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/screenshots/2.png b/Electric_Machinery_and_Transformers_by_Irving_Kosow/screenshots/2.png Binary files differnew file mode 100755 index 00000000..9819d01c --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/screenshots/2.png diff --git a/Electric_Machinery_and_Transformers_by_Irving_Kosow/screenshots/3.png b/Electric_Machinery_and_Transformers_by_Irving_Kosow/screenshots/3.png Binary files differnew file mode 100755 index 00000000..1a8a0721 --- /dev/null +++ b/Electric_Machinery_and_Transformers_by_Irving_Kosow/screenshots/3.png |
