CHAPTER 9: POLYPHASE INDUCTION(ASYNCHRONOUS) DYNAMOS

Example 9.1, Page number 281

In [1]:
#Variable declaration
phase = 3.0   #Number of phases
n = 3.0       #Slots per pole per phase
f = 60.0      #Line frequency(Hz)
f_c = 50.0    #Changed line frequency(Hz)

#Calculation
P = 2*n                    #Number of poles produced
Total_slots = n*P*phase    #Total number of slots on the stator
S_b = 120*f/P              #Speed of the rotating magnetic field or poles(rpm)
S_c = 120*f_c/P            #Speed of the rotating magnetic field(rpm)

#Result
print('Case(a): Number of poles produced , P = %.f poles' %P)
print('         Total number of slots on the stator , Total slots = %.f slots' %Total_slots)
print('Case(b): Speed of the rotating magnetic fields or poles , S = %.f rpm' %S_b)
print('Case(c): Speed of the rotating magnetic field , S = %.f rpm' %S_c)

Case(a): Number of poles produced , P = 6 poles
         Total number of slots on the stator , Total slots = 54 slots
Case(b): Speed of the rotating magnetic fields or poles , S = 1200 rpm
Case(c): Speed of the rotating magnetic field , S = 1000 rpm

Example 9.2, Page number 281

In [1]:
#Variable declaration
s_a = 0.05    #Slip
f_a = 60.0    #Line frequency(Hz)
S_a = 1200.0  #Speed of the rotating magnetic field(rpm)
s_b = 0.07    #Slip
f_b = 50.0    #Line frequency(Hz)
S_b = 1000.0  #Speed of the rotating magnetic field(rpm)

#Calculation
S_r_a = S_a*(1-s_a)  #Full-load rotor speed(rpm)
S_r_b = S_b*(1-s_b)  #Full-load rotor speed(rpm)

#Result
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)
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)

Case(a): Full-load rotor speed if slip is 5 percent slip when the frequency is 60 Hz , S_r = 1140 rpm
Case(b): Full-load rotor speed if slip is 7 percent slip when the frequency is 50 Hz , S_r = 930 rpm

Example 9.3, Page number 283

In [1]:
#Variable declaration
P = 4.0      #Number of poles in Induction motor
f = 60.0     #Frequency(Hz)
s_f = 0.05   #Full-load rotor slip

#Calculation
#Case(a)
s = 1.0          #Slip = 1 at the instant of starting, since S_r = 0
f_r_a = s*f      #Rotor frequency in Hz at the instant of starting
#Case(b)
f_r_b = s_f*f    #Full-load rotor frequency in Hz

#Result
print('Case(a): Rotor frequency at the instant of starting , f_r  = %.f Hz' %f_r_a)
print('Case(b): Rotor frequency at full load , f_r  = %.f Hz' %f_r_b)

Case(a): Rotor frequency at the instant of starting , f_r  = 60 Hz
Case(b): Rotor frequency at full load , f_r  = 3 Hz

Example 9.4, Page number 286

In [1]:
#Variable declaration
P = 4.0          #Number of poles in the induction motor
hp = 50.0        #Rating of the induction motor(hp)
V_o = 208.0      #Voltage rating of the induction motor(V)
T_orig = 225.0   #Starting torque(lb-ft)
I_orig = 700.0   #Instantaneous starting current at rated voltage(A)
V_s = 120.0      #Reduced 3-phase voltage supplied(V)

#Calculation
T_s = T_orig*(V_s/V_o)**2   #Starting torque(lb-ft)
I_s = I_orig*(V_s/V_o)      #Starting current(A)

#Result
print('Case(a): Starting torque , T_s = %.f lb-ft' %T_s)
print('Case(b): Starting current , I_s = %d A' %I_s)

Case(a): Starting torque , T_s = 75 lb-ft
Case(b): Starting current , I_s = 403 A

Example 9.5, Page number 288

In [1]:
#Variable declaration
P = 8.0          #Number of poles in the motor
f = 60.0         #Frequency(Hz)
R_r = 0.3        #Rotor resistance per phase(ohm)
S_r = 650.0      #Speed at which motor stalls(rpm)
s = 0.05         #Rated slip

#Calculation
S = 120*f/P        #Speed of the rotating magnetic field(rpm)
s_b = (S-S_r)/S    #Breakdown Slip
X_lr = R_r/s_b     #Locked rotor reactance(ohm)
f_r = s_b*f        #Rotor frequency at the maximum torque point(Hz)
S_r = S*(1-s)      #Full-load speed at rated slip(rpm)

#Result
print('Case(a): Breakdown slip , s_b = %.3f' %s_b)
print('Case(b): Locked-rotor reactance , X_lr = %.2f Ω' %X_lr)
print('Case(c): Rotor frequency at the maximum torque point , f_r = %.1f Hz' %f_r)
print('Case(d): Full-load speed if the rated slip is 5 percent , S_r = %.f rpm' %S_r)

Case(a): Breakdown slip , s_b = 0.278
Case(b): Locked-rotor reactance , X_lr = 1.08 Ω
Case(c): Rotor frequency at the maximum torque point , f_r = 16.7 Hz
Case(d): Full-load speed if the rated slip is 5 percent , S_r = 855 rpm

Example 9.6, Page number 295

In [1]:
#Variable declaration
P = 8.0             #Number of poles in the motor
f = 60.0            #Frequency(Hz)
R_r = 0.3           #Rotor resistance per phase(ohm/phase)
R_x = 0.7           #Added resistance(ohm/phase)
S_r = 875.0         #Full-load Speed(rpm) 
S = 900.0           #Speed of the rotating magnetic field(rpm)
X_lr = 1.08         #Locked rotor reactance(ohm)

#Calculation
#Case(a)
s = (S-S_r)/S           #Full-load slip,short circuited
R_r_total = R_r+R_x     #Total resistance per phase(ohm)
s_r = R_r_total/R_r*s   #New full-load slip with added resistance
S_r_new = S*(1-s_r)     #New full-load speed(rpm) 
#Case(b)
T_o = R_r/(R_r**2+X_lr**2)               #Original torque
T_f = (R_r+R_x)/((R_r+R_x)**2+X_lr**2)   #New torque
torque_ratio = T_f/T_o                   #Ratio of final torque to original torque
T_final = 2*torque_ratio

#Result
print('Case(a): New full-load speed with added resistance , S(1-s) = %.f rpm' %S_r_new)
print('Case(b): Starting torque with added resistance , T_f = %.2f*T_fl' %T_final)

Case(a): New full-load speed with added resistance , S(1-s) = 817 rpm
Case(b): Starting torque with added resistance , T_f = 3.87*T_fl

Example 9.7, Page number 295

In [1]:
import math
import cmath

#Variable declaration
P = 8.0             #Number of poles in the motor
f = 60.0            #Frequency(Hz)
R_r = 0.3           #Rotor resistance per phase(ohm/phase)
R_x = 0.7           #Added resistance(ohm/phase)
X_lr = 1.08         #Locked rotor reactance(ohm)
E_lr = 112.0        #Induced voltage per phase(V)

#Calculation
#Case(a)
Z_lr = complex(R_r,X_lr)                       #Locked rotor impedance per phase(ohm)
I_r = E_lr/abs(Z_lr)                           #Rotor current per phase(A)
angle_Z_lr = cmath.phase(Z_lr)*180/math.pi     #Angle of locked rotor impedance per phase(degree)
PF = math.cos(angle_Z_lr*math.pi/180)          #PF with rotor short circuited
PF_a = R_r/abs(Z_lr)                           #PF with rotor short circuited
#Case(b)
Z_lr_b = complex(R_r+R_x,X_lr)                 #Locked rotor impedance per phase with added resistance(ohm)
I_r_b = E_lr/abs(Z_lr_b)                       #Rotor current per phase with added resistance(A)
angle_Z_lr_b = cmath.phase(Z_lr_b)*180/math.pi #Angle of locked rotor impedance per phase with added resistance(degree)
PF_2 = math.cos(angle_Z_lr_b*math.pi/180)      #PF with added resistance
PF_b = (R_r+R_x)/abs(Z_lr_b)                   #PF with added resistance

#Result
print('Case(a): Rotor current per phase with rotor short-circuited , I_r = %.fA' %I_r)
print('         Power factor with rotor short-circuited , cosθ = %.3f ' %PF)
print('Case(b): Rotor current per phase with added resistance , I_r = %.1f A' %I_r_b)
print('         Power factor with added resistance , cosθ_r = %.2f ' %PF_2)

Case(a): Rotor current per phase with rotor short-circuited , I_r = 100A
         Power factor with rotor short-circuited , cosθ = 0.268 
Case(b): Rotor current per phase with added resistance , I_r = 76.1 A
         Power factor with added resistance , cosθ_r = 0.68

Example 9.8, Page number 296

In [1]:
import math
import cmath

#Variable declaration
P = 8.0             #Number of poles in the motor
f = 60.0            #Frequency(Hz)
R_r = 0.3           #Rotor resistance per phase(ohm/phase)
R_x = 0.7           #Added resistance(ohm/phase)
X_lr = 1.08         #Locked rotor reactance(ohm)
E_lr = 112.0        #Induced voltage per phase(V)

#Calculation
#Case(a)
T_o = R_r/(R_r**2+X_lr**2)            #Original torque
a = 0.24                              #Co-efficient of x^2
b = -0.856                            #Co-efficient of x
c = 0                                 #Constant
sol_1 = (-b+(b**2-4*a*c)**0.5)/(2*a)  #Solution 1
sol_2 = (-b-(b**2-4*a*c)**0.5)/(2*a)  #Solution 1
R_x = sol_1
R_x2 = sol_2
R_T = R_r+R_x                         #Added rotor resistance(ohm)
#Case(b)
Z_T = complex(R_T,X_lr)               #Impedance(ohm)
angle_Z_T = cmath.phase(Z_T)*180/math.pi #Angle of impedance(degree)
PF = math.cos(angle_Z_T*math.pi/180)  #Rotor PF
PF_b = R_T/abs(Z_T)                   #Rotor PF
#Case(c)
I_r = E_lr/abs(Z_T)                   #Starting current(A)

#Result
print('Case(a): Added rotor resistance , R_T = %.2f Ω' %R_T)
print('Case(b): Rotor power factor that will produce same starting torque , cosθ = %.3f ' %PF)
print('Case(c): Starting current , I_r = %.f A' %I_r)

Case(a): Added rotor resistance , R_T = 3.87 Ω
Case(b): Rotor power factor that will produce same starting torque , cosθ = 0.963 
Case(c): Starting current , I_r = 28 A

Example 9.9, Page number 297

In [1]:
#Variable declaration
P = 8.0             #Number of poles in the motor
f = 60.0            #Frequency(Hz)
R_r = 0.3           #Rotor resistance(ohm)
S_r = 875.0         #Full-load Speed(rpm)
R_x_a = 1.7         #Added rotor resistance(ohm)
R_x_b = 2.7         #Added rotor resistance(ohm)
R_x_c = 3.7         #Added rotor resistance(ohm)
R_x_d = 4.7         #Added rotor resistance(ohm)

#Calculation
S_o = 120*f/P               #Speed of the rotating magnetic field(rpm)
s_o = (S_o-S_r)/S_o         #Full-load slip
s_r_a = s_o*(R_r+R_x_a)/R_r #Slip
S_r_a = S_o*(1-s_r_a)       #Rotor speed(rpm)
s_r_b = s_o*(R_r+R_x_b)/R_r #Slip
S_r_b = S_o*(1-s_r_b)       #Rotor speed(rpm)
s_r_c = s_o*(R_r+R_x_c)/R_r #Slip
S_r_c = S_o*(1-s_r_c)       #Rotor speed(rpm)
s_r_d = s_o*(R_r+R_x_d)/R_r #Slip
S_r_d = S_o*(1-s_r_d)       #Rotor speed(rpm)

#Result
print('Case(a): Full load speed for added rotor resistance of 1.7 Ω , S_r = %.1f rpm' %S_r_a)
print('Case(b): Full load speed for added rotor resistance of 2.7 Ω , S_r = %.f rpm' %S_r_b)
print('Case(c): Full load speed for added rotor resistance of 3.7 Ω , S_r = %d rpm' %S_r_c)
print('Case(d): Full load speed for added rotor resistance of 4.7 Ω , S_r = %.f rpm' %S_r_d)

Case(a): Full load speed for added rotor resistance of 1.7 Ω , S_r = 733.3 rpm
Case(b): Full load speed for added rotor resistance of 2.7 Ω , S_r = 650 rpm
Case(c): Full load speed for added rotor resistance of 3.7 Ω , S_r = 566 rpm
Case(d): Full load speed for added rotor resistance of 4.7 Ω , S_r = 483 rpm

Example 9.10, Page number 302

In [1]:
#Variable declaration
P = 4.0             #Number of poles in WRIM
f = 60.0            #Frequency(Hz)
V = 220.0           #Line voltage(V)
hp = 1.0            #Power rating of WRIM(hp)
S_r = 1740.0        #Full-load rated speed(rpm)
R_r = 0.3           #Rotor resistance(ohm)
X_lr = 1.0          #Locked rotor reactance(ohm)

#Calculation
#Case(a)
V_p = V                #Phase voltage(V)
E_lr = V_p/4           #Locked-rotor voltage per phase(V)
#Case(b)
S = 120*f/P            #Speed of the rotating magnetic field(rpm)
s = (S-S_r)/S          #Slip
I_r = E_lr/((R_r/s)**2+X_lr**2)**0.5 #Rotor current per phase at rated speed(A/phase)
#Case(c)
P_in = I_r**2*R_r/s    #Rated rotor power input per phase(W/phase)
#Case(d)
P_RL = I_r**2*R_r      #Rated rotor copper loss per phase(W/phase)
#Case(e)
P_d = P_in-P_RL        #Rotor power developed per phase(W)
P_d_hp = P_d/746       #Rotor power developed per phase(hp)
#Case(f)
T_d = P_d_hp*5252/S_r  #Rotor torque developed per phase(lb-ft)
T_d2 = 7.04*P_in/S     #Rotor torque developed per phase(lb-ft)
T_dm = 3*T_d           #Total rotor torque(lb-ft)

#Result
print('Case(a): Locked-rotor voltage per phase , E_lr = %.f V' %E_lr)
print('Case(b): Rotor current per phase at rated speed , I_r = %.3f A/phase' %I_r)
print('Case(c): Rated rotor power input per phase , P_in = %.f W/phase' %P_in)
print('Case(d): Rated rotor copper loss per phase , P_RL = %.2f W' %P_RL)
print('Case(e): Rotor power developed per phase , P_d = %.1f W/phase' %P_d)
print('         Rotor power developed per phase , P_d = %.2f hp/phase' %P_d_hp)
print('Case(f): Rotor torque developed per phase by method 1 , T_d = %.1f lb-ft' %T_d)
print('         Rotor torque developed per phase by method 2 , T_d = %.1f lb-ft' %T_d2)
print('         Total rotor torque , T_dm = %.1f lb-ft' %T_dm)

Case(a): Locked-rotor voltage per phase , E_lr = 55 V
Case(b): Rotor current per phase at rated speed , I_r = 6.074 A/phase
Case(c): Rated rotor power input per phase , P_in = 332 W/phase
Case(d): Rated rotor copper loss per phase , P_RL = 11.07 W
Case(e): Rotor power developed per phase , P_d = 320.9 W/phase
         Rotor power developed per phase , P_d = 0.43 hp/phase
Case(f): Rotor torque developed per phase by method 1 , T_d = 1.3 lb-ft
         Rotor torque developed per phase by method 2 , T_d = 1.3 lb-ft
         Total rotor torque , T_dm = 3.9 lb-ft

Example 9.11, Page number 303

In [1]:
#Variable declaration
P = 6.0             #Number of poles in WRIM
f = 60.0            #Frequency(Hz)
V = 208.0           #Line voltage(V)
hp = 7.5            #Power rating of WRIM(hp)
S_r = 1125.0        #Full-load rated speed(rpm)
R_r = 0.08          #Rotor resistance(ohm/phase)
X_lr = 0.4          #Locked rotor reactance(ohm/phase)

#Calculation
#Case(a)
V_p = V/3**0.5         #Phase voltage(V)
E_lr = V_p/2           #Locked-rotor voltage per phase(V)
#Case(b)
S = 120*f/P            #Speed of the rotating magnetic field(rpm)
s = (S-S_r)/S          #Slip
I_r = E_lr/((R_r/s)**2+X_lr**2)**0.5 #Rotor current per phase at rated speed(A/phase)
#Case(c)
P_in = I_r**2*R_r/s    #Rated rotor power input per phase(W/phase)
#Case(d)
P_RL = I_r**2*R_r      #Rated rotor copper loss per phase(W/phase)
#Case(e)
P_d = P_in-P_RL        #Rotor power developed per phase(W)
P_d_hp = P_d/746       #Rotor power developed per phase(hp)
#Case(f)
T_d = P_d_hp*5252/S_r  #Rotor torque developed per phase(lb-ft)
T_d2 = 7.04*P_in/S     #Rotor torque developed per phase(lb-ft)
#Case(g)
T_dm = 3*T_d           #Total rotor torque(lb-ft)
#Case(h)
P_o = hp*746           #Output power(W)
T_o = 7.04*P_o/S_r     #Total output rotor torque(lb-ft)

#Result
print('Case(a): Locked-rotor voltage per phase , E_lr = %.f V' %E_lr)
print('Case(b): Rotor current per phase at rated speed , I_r = %.2f A/phase' %I_r)
print('Case(c): Rated rotor power input per phase , P_in = %.f W/phase' %P_in)
print('Case(d): Rated rotor copper loss per phase , P_RL = %.1f W/phase' %P_RL)
print('Case(e): Rotor power developed per phase , P_d = %.f W/phase' %P_d)
print('         Rotor power developed per phase , P_d = %.2f hp/phase' %P_d_hp)
print('Case(f): Rotor torque developed per phase by method 1 , T_d = %.1f lb-ft/phase' %T_d)
print('         Rotor torque developed per phase by method 2 , T_d = %.1f lb-ft/phase' %T_d2)
print('Case(g): Total rotor torque , T_dm = %.f lb-ft' %T_dm)
print('Case(h): Total output rotor torque , T_o = %.f lb-ft' %T_o)
print('\nNOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places')

Case(a): Locked-rotor voltage per phase , E_lr = 60 V
Case(b): Rotor current per phase at rated speed , I_r = 44.77 A/phase
Case(c): Rated rotor power input per phase , P_in = 2566 W/phase
Case(d): Rated rotor copper loss per phase , P_RL = 160.4 W/phase
Case(e): Rotor power developed per phase , P_d = 2406 W/phase
         Rotor power developed per phase , P_d = 3.22 hp/phase
Case(f): Rotor torque developed per phase by method 1 , T_d = 15.1 lb-ft/phase
         Rotor torque developed per phase by method 2 , T_d = 15.1 lb-ft/phase
Case(g): Total rotor torque , T_dm = 45 lb-ft
Case(h): Total output rotor torque , T_o = 35 lb-ft

NOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places

Example 9.12, Page number 304

In [1]:
#Variable declaration
P = 4.0             #Number of poles in WRIM
f = 60.0            #Frequency(Hz)
V = 220.0           #Line voltage(V)
hp = 1.0            #Power rating of WRIM(hp)
R_r = 0.3           #Rotor resistance(ohm)
X_lr = 1.0          #Locked rotor reactance(ohm)
n = 3.0             #Number of phases

#Calculation
V_p = V                     #Phase voltage(V)
E_lr = V_p/4                #Locked-rotor voltage per phase(V)
P_in = E_lr**2/(2*X_lr)*n   #Total 3-phase rotor power input(W)
S = 120*f/P                 #Speed of the rotating magnetic field(rpm)
T_max = 7.04*P_in/S         #Maximum torque developed(lb-ft)
s_b = R_r/X_lr              #Slip
S_r = S*(1-s_b)             #Speed at which maximum torque is developed(rpm)

#Result
print('Maximum torque developed , T_max = %.2f lb-ft' %T_max)
print('Percent slip , s_b = %.f percent' %(s_b*100))
print('Speed at which maximum torque is developed , S_r = %.f rpm' %S_r)

Maximum torque developed , T_max = 17.75 lb-ft
Percent slip , s_b = 30 percent
Speed at which maximum torque is developed , S_r = 1260 rpm

Example 9.13, Page number 304

In [1]:
#Variable declaration
P = 4.0             #Number of poles in WRIM
f = 60.0            #Frequency(Hz)
V = 220.0           #Line voltage(V)
hp = 1.0            #Power rating of WRIM(hp)
R_r = 0.3           #Rotor resistance(ohm)
X_lr = 1.0          #Locked rotor reactance(ohm)
n = 3.0             #Number of phases

#Calculation
V_p = V                                  #Phase voltage(V)
E_lr = V_p/4                             #Locked-rotor voltage per phase(V)
P_in = n*(E_lr**2/(R_r**2+X_lr**2))*R_r  #Total 3-phase rotor power input(W)
S = 120*f/P                              #Speed of the rotating magnetic field(rpm)
T_s = 7.04*P_in/S                        #Starting torque developed(lb-ft)

#Result
print('Starting torque developed , T_s = %.2f lb-ft' %T_s)

Starting torque developed , T_s = 9.77 lb-ft

Example 9.14, Page number 306

In [1]:
#Variable declaration
T_max = 17.75     #Maximum torque developed(lb-ft)
s_max = 0.3       #Slip for which T_max occurs
s_a = 0.0333      #Slip
s_b = 1.0         #Slip 

#Calculation
T_a = T_max*(2/((s_max/s_a)+(s_a/s_max)))   #Full-load torque(lb-ft)
T_b = T_max*(2/((s_max/s_b)+(s_b/s_max)));  #Starting torque(lb-ft)

#Result
print('Case(a): Full-load torque at a slip of 0.0333 , T = %.1f lb-ft' %T_a)
print('Case(b): Starting torque at a slip of 1.0 , T = %.2f lb-ft' %T_b)

Case(a): Full-load torque at a slip of 0.0333 , T = 3.9 lb-ft
Case(b): Starting torque at a slip of 1.0 , T = 9.77 lb-ft

Example 9.15, Page number 307

In [1]:
import math
import cmath
import numpy

#Variable declaration
P = 4.0            #Number of poles in SCIM 
S_r = 1746.0       #Rated rotor speed(rpm)
V = 220.0          #Voltage rating of SCIM(V)
f = 60.0           #Frequency(Hz)
P_hp = 10.0        #Power rating of SCIM(hp)
R_a = 0.4          #Armature resistance(ohm)
R_r = 0.14         #Rotor resistance(ohm)
jXm = 16.0         #Reactance(ohm)
jXs = 0.35         #Synchronous reactance(ohm)
jXlr = 0.35        #Locked rotor reactance(ohm)
P_r_total = 360.0  #Total rotational losses(W)

#Calculation
V_p = V/3**0.5     #Voltage per phase(V)
S = 120*f/P        #Speed of the rotating magnetic field(rpm)
s = (S-S_r)/S      #Slip
I1_1 = complex(R_a,jXm+jXs)
I1_2 = complex(0,-jXm)
I2_1 = complex(0,-jXm)
I2_2 = complex(R_r/s,jXm+jXlr)
V_1 = V_p
V_2 = 0
A = [[I1_1,I2_1],[I1_2,I2_2]]        #Matrix containing above mesh eqns array
delta = numpy.linalg.det(A)          #Determinant of A
#Case(a)
I_p = numpy.linalg.det([[V_1,I2_1],[V_2,I2_2]])/delta #Stator armature current(A)
I_1 = I_p
#Case(b)
I_r = numpy.linalg.det([[I1_1,V_1],[I1_2,V_2]])/delta #Rotor armature current(A)
I_2 = I_r
#Case(c)
theta_1 = cmath.phase(I_p)*180/math.pi           #Motor PF angle(degrees)
cos_theta1 = math.cos(theta_1*math.pi/180)       #Motor PF
#Case(d)
SPI = V_p*abs(I_p)*cos_theta1                    #Stator power input(W)
#Case(e)
SCL = abs(I_p)**2 *R_a                           #Stator Copper Loss(W)
#Case(f)
RPI = SPI-SCL                                    #Rotor power input(W) Method 1
RPI_2 = abs(I_r)**2*(R_r/s)                      #Rotor power input(W) Method 2
#Case(g)
RPD = RPI*(1-s)                                  #Rotor power developed(W) Method 1
RCL = s*RPI                                      #Rotor copper losses(W)
RPD_2 = RPI-RCL                                  #Rotor power developed(W) Method 2
RPD_3 = abs(I_r)**2*R_r*(1-s)/s                  #Rotor power developed(W) Method 3
#Case(h)
P_r = P_r_total/3                                #Rotational losses per phase(W)
P_o = RPD-P_r                                    #Rotor power per phase(W)
P_to = 3.0*P_o                                   #Total rotor power at the motor pulley(W)
#Case(i)
T = 7.04*(P_to/S_r)                              #Total 3-phase torque(lb-ft)
#Case(j)
P_t = P_to 
hp = P_t/746.0                                   #Output horsepower(hp)
#Case(k)
P_in = SPI                                       #Input power to stator(W)
n = P_o/P_in*100                                 #Motor efficiency at rated load(%)

#Result
print('Case(a): Stator armature current , I_p = %.2f∠%.2f° A  (lagging)' %(abs(I_p),cmath.phase(I_p)*180/math.pi))
print('Case(b): Rotor current per phase , I_r = %.3f∠%.2f° A  (lagging)' %(abs(I_r),cmath.phase(I_r)*180/math.pi))
print('Case(c): Motor power factor , cos Ө_1 = %.4f' %cos_theta1)
print('Case(d): Stator power input , SPI = %d W' %SPI)
print('Case(e): Stator copper loss , SCL = %d W' %SCL)
print('Case(f): Rotor power input , RPI = %d W (Method 1)' %RPI)
print('         Rotor power input , RPI = %d W (Method 2)' %RPI_2)
print('Case(g): Rotor power developed , RPD = %d W (Method 1)' %RPD)
print('         Rotor power developed , RPD = %d W (Method 2)' %RPD_2)
print('         Rotor power developed , RPD = %d W (Method 3)' %RPD_3)
print('Case(h): Total rotor power at the motor pulley , P_to = %d W' %P_to)
print('Case(i): Total three-phase output torque , T = %d lb-ft' %T)
print('Case(j): Output horsepower , hp = %.1f hp' %hp)
print('Case(k): Motor efficiency at rated load , η = %.1f percent' %n)
print('\nNOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places')

Case(a): Stator armature current , I_p = 25.90∠-22.44° A  (lagging)
Case(b): Rotor current per phase , I_r = 24.374∠-6.51° A  (lagging)
Case(c): Motor power factor , cos Ө_1 = 0.9243
Case(d): Stator power input , SPI = 3040 W
Case(e): Stator copper loss , SCL = 268 W
Case(f): Rotor power input , RPI = 2772 W (Method 1)
         Rotor power input , RPI = 2772 W (Method 2)
Case(g): Rotor power developed , RPD = 2689 W (Method 1)
         Rotor power developed , RPD = 2689 W (Method 2)
         Rotor power developed , RPD = 2689 W (Method 3)
Case(h): Total rotor power at the motor pulley , P_to = 7707 W
Case(i): Total three-phase output torque , T = 31 lb-ft
Case(j): Output horsepower , hp = 10.3 hp
Case(k): Motor efficiency at rated load , η = 84.5 percent

NOTE: Changes in obtained answer from that of textbook is due to more precision i.e more number of decimal places

Example 9.16, Page number 313

In [1]:
#Variable declaration
V = 208.0      #Rated voltage(V)
P_o = 15.0     #Rated power(hp)
I = 42.0       #Rated current(A)
I_st = 252.0   #Starting current(A)
T_st = 120.0   #Full-voltage starting torque(lb-ft)
tap = 0.6      #Tapping employed by compensator

#Calculation
I_sm = tap*I_st                 #Motor starting current at reduced voltage(A) 
I_L = tap*I_sm                  #Motor line current(A)
T_s = tap**2*T_st               #Motor starting torque at reduced voltage(lb-ft)
percent_I_L = I_L/I_st*100      #Percent line current at starting
percent_T_st = T_s/T_st*100     #Percent motor starting torque

#Result
print('Case(a): Motor starting current at reduced voltage , I_sm = %.1f A to the motor' %I_sm)
print('Case(b): Motor line current neglecting tarnsformer exciting current and losses , I_L = %.2f A drawn from the mains' %I_L)
print('Case(c): Motor starting torque at reduced voltage , T_s = %.1f lb-ft' %T_s)
print('Case(d): Percent line current at starting = %.f percent of line current at full voltage' %percent_I_L)
print('Case(e): Percent motor starting torque = %.f percent of starting torque at full voltage' %percent_T_st)

Case(a): Motor starting current at reduced voltage , I_sm = 151.2 A to the motor
Case(b): Motor line current neglecting tarnsformer exciting current and losses , I_L = 90.72 A drawn from the mains
Case(c): Motor starting torque at reduced voltage , T_s = 43.2 lb-ft
Case(d): Percent line current at starting = 36 percent of line current at full voltage
Case(e): Percent motor starting torque = 36 percent of starting torque at full voltage

Example 9.17, Page number 324

In [1]:
#Variable declaration
V_o = 220.0      #Rated voltage(V)
P = 4.0          #Number of poles in SCIM
P_o = 10.0       #Rated power(hp)
T_o = 30.0       #Rated torque(lb-ft)
S_r = 1710.0     #Rated rotor speed(rpm)
V_n1 = 242.0     #Impressed stator voltage(V) Case(a)
V_n2 = 198.0     #Impressed stator voltage(V) Case(b)
f = 60.0         #Frequency(Hz) assumption

#Calculation
S = (120*f)/P               #Speed of the rotating magnetic field(rpm)
s_o = (S-S_r)/S             #Rated slip
#Case(a)
T_n1 = T_o*(V_n1/V_o)**2    #New torque(lb-ft)
s_n1 = s_o*(T_o/T_n1)       #New slip
S_rn1 = S*(1-s_n1)          #New speed(rpm)
#Case(b)
T_n2 = T_o*(V_n2/V_o)**2    #New torque(lb-ft)
s_n2 = s_o*(T_o/T_n2)       #New slip
S_rn2 = S*(1-s_n2)          #New speed(rpm)
#Case(c)
percent_slip_a = (s_o-s_n1)/s_o*100    #Percent change in slip in part(a)
percent_speed_a = (S_rn1-S_r)/S_r*100  #Percent change in speed in part(a)
#Case(d)
percent_slip_b = (s_n2-s_o)/s_o*100    #Percent change in slip in part(b)
percent_speed_b = (S_r-S_rn2)/S_r*100  #Percent change in speed in part(b)

#Result
print('Case(a): New torque at an impressed stator voltage of 242 V , T_n = %.1f lb-ft' %T_n1)
print('         New slip , s_n = %.4f ' %s_n1)
print('         New speed , S_rn = %.f rpm' %S_rn1)
print('Case(b): New torque at an impressed stator voltage of 198 V , T_n = %.1f lb-ft' %T_n2)
print('         New slip , s_n = %.4f ' %s_n2)
print('         New speed , S_rn = %.f rpm' %S_rn2)
print('Case(c): Percentage change in slip due to voltage change in part a = %.1f percent decrease' %percent_slip_a)
print('         Percentage change in speed = %.2f percent increase' %percent_speed_a)
print('Case(d): Percentage change in slip due to voltage change in part b = %.1f percent increase' %percent_slip_b)
print('         Percentage change in speed = %.2f percent decrease' %percent_speed_b)

Case(a): New torque at an impressed stator voltage of 242 V , T_n = 36.3 lb-ft
         New slip , s_n = 0.0413 
         New speed , S_rn = 1726 rpm
Case(b): New torque at an impressed stator voltage of 198 V , T_n = 24.3 lb-ft
         New slip , s_n = 0.0617 
         New speed , S_rn = 1689 rpm
Case(c): Percentage change in slip due to voltage change in part a = 17.4 percent decrease
         Percentage change in speed = 0.91 percent increase
Case(d): Percentage change in slip due to voltage change in part b = 23.5 percent increase
         Percentage change in speed = 1.23 percent decrease

Example 9.18, Page number 324

In [1]:
#Variable declaration
V_o = 220.0      #Rated voltage(V)
P = 4.0          #Number of poles in SCIM
P_o = 10.0       #Rated power(hp)
R_ro = 0.3       #Rotor resistance(ohm)
R_re = 1.7       #External rotor resistance(ohm)
T_o = 30.0       #Rated torque(lb-ft)
S_r = 1750.0     #Rated rotor speed(rpm)
V_n1 = 240.0     #Impressed stator voltage(V) Case(a)
V_n2 = 208.0     #Impressed stator voltage(V) Case(b)
V_n3 = 110.0     #Impressed stator voltage(V) Case(c)
f = 60.0         #Frequency(Hz) assumption

#Calculation
S = (120*f)/P                      #Speed of the rotating magnetic field(rpm)
s_o = (S-S_r)/S                    #Rated slip
R_rn = R_ro+R_re                   #Resistance(ohm)
#Case(a)
T_n1 = T_o*(V_n1/V_o)**2           #New torque(lb-ft)
s_n1 = s_o*(T_o/T_n1)*(R_rn/R_ro)  #New slip
S_rn1 = S*(1-s_n1)                 #New speed(rpm)
#Case(b)
T_n2 = T_o*(V_n2/V_o)**2           #New torque(lb-ft)
s_n2 = s_o*(T_o/T_n2)*(R_rn/R_ro)  #New slip
S_rn2 = S*(1-s_n2)                 #New speed(rpm)
#Case(c)
T_n3 = T_o*(V_n3/V_o)**2           #New torque(lb-ft)
s_n3 = s_o*(T_o/T_n3)*(R_rn/R_ro)  #New slip
S_rn3 = S*(1-s_n3)                 #New speed(rpm)

#Result
print('Case(a): New torque at an impressed stator voltage of 240 V , T_n = %.1f lb-ft' %T_n1)
print('         New slip , s_n = %.4f ' %s_n1)
print('         New speed , S_rn = %.f rpm' %S_rn1)
print('Case(b): New torque at an impressed stator voltage of 208 V , T_n = %.2f lb-ft' %T_n2)
print('         New slip , s_n = %.3f ' %s_n2)
print('         New speed , S_rn = %.f rpm' %S_rn2)
print('Case(c): New torque at an impressed stator voltage of 110 V , T_n = %.1f lb-ft' %T_n3)
print('         New slip , s_n = %.3f ' %s_n3)
print('         New speed , S_rn = %.f rpm' %S_rn3)

Case(a): New torque at an impressed stator voltage of 240 V , T_n = 35.7 lb-ft
         New slip , s_n = 0.1556 
         New speed , S_rn = 1520 rpm
Case(b): New torque at an impressed stator voltage of 208 V , T_n = 26.82 lb-ft
         New slip , s_n = 0.207 
         New speed , S_rn = 1427 rpm
Case(c): New torque at an impressed stator voltage of 110 V , T_n = 7.5 lb-ft
         New slip , s_n = 0.741 
         New speed , S_rn = 467 rpm

Example 9.19, Page number 327

In [1]:
#Variable declaration
P = 8.0            #Number of poles in WRIM
f = 60.0           #Operating frequency of the WRIM(Hz)
S_con_a1 = 1800.0  #Speed of the convertor(rpm)
S_con_a2 = 450.0   #Speed of the convertor(rpm)
f_con_b1 = 25.0    #Frequency of an induction converter(Hz)
f_con_b2 = 400.0   #Frequency of an induction converter(Hz)
f_con_b3 = 120.0   #Frequency of an induction converter(Hz)

#Calculation
S = (120*f)/P                  #Speed of the rotating magnetic field(rpm)
#Case(a)
f_con_a1 = f*(1+S_con_a1/S)    #Frequency of an induction converter(Hz)
f_con_a2 = f*(1-S_con_a2/S)    #Frequency of an induction converter(Hz)
#Case(b)
S_con_b1 = (-1+f_con_b1/f)*S   #Speed of the converter(rpm)
S_con_b2 = (-1+f_con_b2/f)*S   #Speed of the converter(rpm)
S_con_b3 = (-1+f_con_b3/f)*S   #Speed of the converter(rpm)

#Result
print('Case(a): Frequency , f_con = %.f Hz for %d rpm in opposite direction' %(f_con_a1,S_con_a1))
print('         Frequency , f_con = %.f Hz for %d rpm in same direction' %(f_con_a2,S_con_a2))
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)))
print('       2: Speed and direction to obtain 400 Hz , S_con = %.f rpm in opposite direction' %S_con_b2)
print('       3: Speed and direction to obtain 120 Hz , S_con = %.f rpm in opposite direction to rotating stator flux' %S_con_b3)

Case(a): Frequency , f_con = 180 Hz for 1800 rpm in opposite direction
         Frequency , f_con = 30 Hz for 450 rpm in same direction
Case(b)1: Speed and direction to obtain 25 Hz , S_con = -525 rpm, or 525 rpm in same direction
       2: Speed and direction to obtain 400 Hz , S_con = 5100 rpm in opposite direction
       3: Speed and direction to obtain 120 Hz , S_con = 900 rpm in opposite direction to rotating stator flux