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)
```

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)
```

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)
```

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)
```

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)
```

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)
```

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)
```

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)
```

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)
```

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)
```

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')
```

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)
```

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)
```

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)
```

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')
```

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)
```

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)
```

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)
```

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)
```