diff options
| author | hardythe1 | 2015-04-07 15:58:05 +0530 |
|---|---|---|
| committer | hardythe1 | 2015-04-07 15:58:05 +0530 |
| commit | 92cca121f959c6616e3da431c1e2d23c4fa5e886 (patch) | |
| tree | 205e68d0ce598ac5caca7de839a2934d746cce86 /Electric_Machinery_and_Transformers/CHAP_9.ipynb | |
| parent | b14c13fcc6bb6d01c468805d612acb353ec168ac (diff) | |
| download | Python-Textbook-Companions-92cca121f959c6616e3da431c1e2d23c4fa5e886.tar.gz Python-Textbook-Companions-92cca121f959c6616e3da431c1e2d23c4fa5e886.tar.bz2 Python-Textbook-Companions-92cca121f959c6616e3da431c1e2d23c4fa5e886.zip | |
added books
Diffstat (limited to 'Electric_Machinery_and_Transformers/CHAP_9.ipynb')
| -rwxr-xr-x | Electric_Machinery_and_Transformers/CHAP_9.ipynb | 1133 |
1 files changed, 1133 insertions, 0 deletions
diff --git a/Electric_Machinery_and_Transformers/CHAP_9.ipynb b/Electric_Machinery_and_Transformers/CHAP_9.ipynb new file mode 100755 index 00000000..282faf96 --- /dev/null +++ b/Electric_Machinery_and_Transformers/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 |