In [197]:

```
import math
from __future__ import division
import cmath
#variable declaration
#ratings of the Y-connected induction motor
f=50 # frequency in HZ
Vl=440 #line voltage in V
P=6 # number of poles
N=950 #speed in rpm
#parameters referred to the stator
Xr_=1.2 # rotor winding reactance in ohm
Rr_=0.4 # resistance of the rotor windings in ohm
Rs=0.5 # resistance of the stator windings in ohm
Xs=Xr_ # stator winding reactance in ohm
Xm=50 # no load reactance
#calculation
Ns=120*f/P #synchronous speed in rpm
s=(Ns-N)/Ns #full load slip
x=math.sqrt((Rs+Rr_/s)**2+(Xs+Xr_)**2) #total impedance
Ir_=(Vl/math.sqrt(3))/x #full load rotor current
angle=-math.atan((Xs+Xr_)/(Rs+Rr_/s)) #angle in radian
Ir_=cmath.rect(Ir_,angle) #full load rotor current in rectangular form
Im=Vl/math.sqrt(3)/Xm*(-1j) #magnetizing current
Is=Ir_+Im #full load current
Zf=Rs+Xs*1j+1j*Xm*(Rr_/s+1j*Xr_)/(Rr_/s+1j*(Xr_+Xm))
Zb=Rs+Xs*1j+1j*Xm*(Rr_/(2-s)+1j*Xr_)/(Rr_/(2-s)+1j*(Xr_+Xm))
Z=Zf+Zb
I=(Vl/math.sqrt(3))/abs(Z) #motor current
Wms=2*math.pi*Ns/60
#torque due to positive sequence
Tp=(1/Wms)*(3*I**2*Xm**2*Rr_/s)/((Rr_/s)**2+(Xr_+Xm)**2)
#torque due to negative sequence
Tn=-(1/Wms)*(3*I**2*Xm**2*Rr_/(2-s))/((Rr_/(2-s))**2+(Xr_+Xm)**2)
T=Tp+Tn #net torque
Wm=Wms*(1-s) #rated speed in in rad/sec
Tl=0.0123*Wm**2 #required torque of the load
#results
print"Full load motor current Is:",round(abs(Is),1),round(math.degrees(cmath.phase(Is))),"°","A"
print"Tp:",round(Tp,2),"N-m"
print"Tn:",round(Tn,3),"N-m"
print"\nSince I:",round(I,2),"A and N:",N,"rpm"
print"And I:",round(I,2),"A <","Is:",round(abs(Is),2),"A, the motor will run safely"
```

In [199]:

```
import math
from __future__ import division
import cmath
#variable declaration
#ratings of the Delta connected Induction motor
f=50 #frequency in HZ
Vl=2200 #line voltage in V
P=8 #number of poles
N=735 #rated speed in rpm
#parameters referred to the stator
Xr_=0.55 # rotor winding reactance in ohm
Xs=0.45 # stator winding reactance in ohm
Rr_=0.1 # resistance of the rotor windings in ohm
Rs=0.075 # resistance of the stator windings in ohm
#calculation
Ns=120*f/P #synchronous speed in rpm
s=(Ns-N)/Ns #full load slip
x=math.sqrt((Rs+Rr_/s)**2+(Xs+Xr_)**2) #total impedance
Ip=(Vl)/x #full load phase current
Il=math.sqrt(3)*Ip #full load line current
Wms=2*math.pi*Ns/60
Tl=(1/Wms)*(3*Ip**2*Rr_/s) #full load torque
#(i)if the motor is started by star-delta switching
y=math.sqrt((Rs+Rr_)**2+(Xs+Xr_)**2)
Ist=(Vl/math.sqrt(3))/y #Maximum line current during starting
Tst=(1/Wms)*(3*Ist**2*Rr_) #Starting torque
ratio1=Tst/Tl #ratio of starting torque to full load torque
z=Rs+math.sqrt(Rs**2+(Xs+Xr_)**2)
Tmax=3/(2*Wms)*(Vl/math.sqrt(3))**2/z #maximum torque
ratio2=Tmax/Tl #ratio of maximum torque to full load torque
#(ii) If the motor is started using auto transformer
y=math.sqrt((Rs+Rr_)**2+(Xs+Xr_)**2)
Ist1=Vl*math.sqrt(3)/y #starting current direct online
aT=math.sqrt(2*Il/Ist1) #transofrmation ratio
Ilst=2*Il/aT #starting motor line current
Ipst=Ilst/math.sqrt(3) #starting motor phase current
Tst1=(1/Wms)*(3*Ipst**2*Rr_) #starting torque
#(iii) If motor is started using part winding method
Rs_=2*Rs
Xs_=2*Xs
y=math.sqrt((Rs_+Rr_)**2+(Xs_+Xr_)**2)
Ist2=(Vl*math.sqrt(3))/y #starting line current
Ip=Ist2/math.sqrt(3) #starting phase current
Tst2=(1/Wms)*(3*Ip**2*Rr_) #starting torque
#(iv) motor is started using series reactors in line
Rs_=Rs/3 ; Rr_=Rr_/3
Xs_=Xs/3 ; Xr_=Xr_/3
Il=2*Il #line current at start
x=(Vl/math.sqrt(3))**2/(Il**2) #x=(Rs_+Rr_)**2+(Xs_+Xr_+Xe)**2
y=x-(Rs_+Rr_)**2 #y=(Xs_+Xr_+Xe)**2
z=math.sqrt(y) #z=(Xs_+Xr_+Xe)
Xe=z-Xs_-Xr_
#results
print"(i)Maximum value of line current during starting Ist:",round(Ist),"A"
print" Ratio of starting torque to full load torque :",round(ratio1,3)
print" Ratio of maximum torque to full load torque :",round(ratio2,2)
print"\n(ii)transofrmation ratio aT:",round(aT,3)
print" starting torque :",round(Tst1),"N-m"
#answer for the starting torque in the book is wrong due to accuracy
print"\n(iii)maixmum line current during starting :",round(Ist2),"A"
print" Starting torque :",round(Tst2),"N-m"
#answer for the starting torque in the book is wrong due to accuracy
print"\n(iv)value of the reactor Xe:",round(Xe,3),"ohm"
```

In [202]:

```
import math
from __future__ import division
import cmath
#variable declaration
#ratings of the star connected Induction motor
f=50 # frequency in HZ
Vl=400 # line voltage in V
P=6 # number of poles
#parameters referred to the stator
Xr_=2 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=1 # resistance of the rotor windings in ohm
Rs=Rr_ # resistance of the stator windings in ohm
#calculation
Ns=120*f/P #synchronous speed in rpm
Wms=2*math.pi*Ns/60
#(i)
Sm=-Rr_/math.sqrt(Rs**2+(Xs+Xr_)**2) #slip at maximum torque
x=math.sqrt((Rs+Rr_/Sm)**2+(Xs+Xr_)**2)
Ir_=(Vl/math.sqrt(3))/x #current at maximum torque
Tmax=(1/Wms)*3*Ir_**2*Rr_/Sm #maximum torque
N=(1-Sm)*Ns #range of speed
#(ii)an overhauling torque of 100Nm
Tl=100 #overhauling torque in Nm
# Tl=(3/Wms)*(Vl**2*Rr_/s)/y
# where y=(Rs+Rr_/s)**2+(Xs+Xr_)**2
a=(1/Wms)*(Vl**2*Rr_)/(-Tl) #a=s*(Rs+Rr_/s)**2+(Xs+Xr_)**2
a = 17
b = 17.3
c = 1
# calculate the discriminant
d = (b**2) - (4*a*c)
# find two solutions
s1 = (-b-cmath.sqrt(d))/(2*a)
s2 = (-b+cmath.sqrt(d))/(2*a)
N2=(1-s2)*Ns #motor speed and we neglect s1
#slight difference in the answer due to accuracy
#(iii)when a capacitive reactance of 2 ohm is inserted in each phase stator
Xc=2 #reactance of the capacitor
Sm=-Rr_/math.sqrt(Rs**2+(Xs+Xr_-Xc)**2) #slip at maximum torque
x=math.sqrt((Rs+Rr_/Sm)**2+(Xs+Xr_-Xc)**2)
Ir_=(Vl/math.sqrt(3))/x #current at maximum torque
Tmax_=(1/Wms)*3*Ir_**2*Rr_/Sm #maximum overhauling torque with capacitor
ratio=Tmax_/Tmax
#results
print"(i)Maximum overhauling torque that the motor can hold is:",round(abs(Tmax),1),"N-m"
print" Range of speed is from ",Ns,"to",round(N),"rpm"
print"\n(ii)Now s*(1+1/s)**2+16s=",a
print" Or 17s**s+17.3s+1=0"
print"The solution for s are ",round(s1.real,3),"and",round(s2.real,3)
print"\nTherefore Motor speed is: ",round(abs(N2)),"rpm"
print"Note :There is a slight difference in the answer due to the decimal place"
print"\n(iii) Ratio of maximum torque with capacitor and to maximum torque without capacitor is:",round(ratio,2)
```

In [203]:

```
import math
from __future__ import division
import cmath
#variable declaration
#ratings of the motor is same as that of Ex-6.3
f=50 # frequency in HZ
Vl=400 #line voltage in V
P=6 # number of poles
#parameters referred to the stator
Xr_=2 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=1 # resistance of the rotor windings in ohm
Rs=Rr_ # resistance of the stator windings in ohm
N=950 #full load speed in rpm
SR=2.3 #stator to rotor turns ratio
#calculation
Ns=120*f/P #synchronous speed in rpm
Wms=2*math.pi*Ns/60
s=(Ns-N)/Ns #full load slip
x=math.sqrt((Rs+Rr_/s)**2+(Xs+Xr_)**2)
Irf_=(Vl/math.sqrt(3))/x #full load current
Tf=(1/Wms)*3*Irf_**2*Rr_/s #full load torque
#(i)initial braking current and torque
S=2-s #during plugging at 950rpm
y=math.sqrt((Rs+Rr_/S)**2+(Xs+Xr_)**2)
Ir_=(Vl/math.sqrt(3))/y #initial braking current
ratio1=Ir_/Irf_
T=(1/Wms)*3*Ir_**2*Rr_/S #initial braking torque
ratio2=T/Tf
#(ii)when an external resistance is connected such
#that maximum braking current is 1.5 times the full load current
Ir_=1.5*Irf_
x=(Vl/math.sqrt(3))/Ir_ #x=math.sqrt((Rs+(Rr_+Re_)/S)**2+(Xs+Xr_)**2)
y=x**2 #y=(Rs+(Rr_+Re_)/S)**2+(Xs+Xr_)**2
z=y-(Xs+Xr_)**2 #z=(Rs+(Rr_+Re_)/S)**2
a=math.sqrt(z) #a=(Rs+(Rr_+Re_)/S)
b=(a-Rs)*S #b=(Rr_+Re_)
Re_=b-Rs
Re=Re_/SR**2
T=(1/Wms)*3*Ir_**2*(Rr_+Re_)/S #initial braking torque
ratio=T/Tf
#results
print"(i)Ratio of initial braking current to full load current is:",round(ratio1)
print" Ratio of initial braking torque to full load torque is:",round(ratio2,2)
print"\n(ii)Ratio of initial braking torque to full load torque when the resistance is added is:",round(ratio,3)
```

In [204]:

```
import math
from __future__ import division
import cmath
#variable declaration
#ratings of the star connected Induction motor
f=50 # frequency in HZ
Vl=440 # line voltage in V
P=6 # number of poles
Vp=Vl/math.sqrt(3) #phase voltage
#parameters referred to the stator
Xr_=1.2 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=0.4 # resistance of the rotor windings in ohm
Rs=0.5 # resistance of the stator windings in ohm
Xm=50 # no load reactance
N=950 # full load speed
Sm=2 # slip at maximum torque
#calculation
Rr_=Sm*math.sqrt(Rs**2+(Xs+Xr_)**2) #Since Sm=Rr_/math.sqrt(Rs**2+(Xs+Xr_)**2)
Ns=120*f/P #synchronous speed in rpm
Wms=2*math.pi*Ns/60
s=(Ns-N)/Ns #slip at 950 rpm
x=1j*Xm*(Rr_/s+1j*Xr_)
y=Rr_/s+1j*(Xr_+Xm)
Zp=Rs+1j*Xs+x/y
Ip=Vp/math.sqrt(3)/Zp #In the book the value of Ip is wrong which leads to other subsequent wrong answers in the book
Irp_=Ip*(1j*Xm)/(Rr_/s+1j*(Xr_+Xm))
Tp=(1/Wms)*3*abs(Irp_)**2*Rr_/s
x=1j*Xm*(Rr_/(2-s)+1j*Xr_)
y=Rr_/(2-s)+1j*(Xr_+Xm)
Zn=Rs+1j*Xs+x/y
In=Vp/math.sqrt(3)/Zn
Irn_=In*(1j*Xm)/(Rr_/(2-s)+1j*(Xr_+Xm))
Tn=-(1/Wms)*3*abs(Irn_)**2*Rr_/(2-s) #In the book the value of In is wrong
T=Tp-Tn
I=abs(Ip)+abs(In)
Rr_=0.4 # from the parameters of the motor referred to the stator
x=math.sqrt((Rs+Rr_/s)**2+(Xs+Xr_)**2)
If=(Vl/math.sqrt(3))/x #full load current
Tf=(1/Wms)*3*If**2*Rr_/s #full load torque
ratio1=I/If
ratio2=abs(T)/Tf
#results
print"Ratio of braking current to full load current is:",round(ratio1,3)
print"Ratio of braking torque to full load torque is:",round(ratio2,3)
#answer in the book is wrong
```

In [8]:

```
import math
from __future__ import division
from array import array
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cbook as cbook
%matplotlib inline
#variable declaration
#ratings of the star connected Induction motor which operates under dynamic braking
f=50 # frequency in HZ
P=4 # number of poles
#parameters referred to the stator
Xr_=3.01 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=4.575 # resistance of the rotor windings in ohm
Rs=1.9 # resistance of the stator windings in ohm
J=0.1 # moment of inertia of the motor load system in kg-m2
Id=12 # given DC current
N=1500 #given asynchronous speed
#magnetization chacrateristic at the given asynchronous speed
Im=[0.13,0.37,0.6,0.9,1.2,1.7,2.24,2.9,3.9,4.9,6,8,9,9.5] #magnetization current
E=[12.8,32,53.8,80,106,142,173,200,227,246,260,280,288,292] #back emf
#calculation
torque=[]
speed=[]
temp=[]
Is=math.sqrt(2/3)*Id #value of stator current for two lead connection
Wms=2*math.pi*N/60
for i in range (1,14,1):
x=(Is**2-Im[i]**2)/(1+2*Xr_*Im[i]/E[i]) #x=Ir_**2
Ir_=math.sqrt(x) #required rotor current
y=(E[i]/Ir_)**2-Xr_**2
S=Rr_/math.sqrt(y) #required slip
N=S*Ns #required speed
T=(3/Wms)*(Ir_)**2*Rr_/S #required torque
speed.append(round(N))
torque.append(round(T,1))
temp.append(round(T,1))
print"Hence the magnetizatioin curve is"
print"Speed :",speed,"rpm"
for i in range(0,13,1):
torque[i]=-1*torque[i]
print"Braking torque is :",torque,"N-m"
#results
#plot of of torque vs speed
plt.figure(1)
plt.plot(torque,speed)
plt.xlabel('Torque, N-m')
plt.ylabel('Speed, rpm')
plt.title('Torque vs Speed')
plt.grid(True)
plt.tight_layout()
plt.show()
#plot of Wm vs J/T
inertia_over_torque=[]
for i in range(2,13,1):
J_T=1000*J/temp[i]
inertia_over_torque.append(round(J_T,4))
print"J/t :",inertia_over_torque
Wm=[1,4,8,12,16,20,25,55,95,125,160]
#the values of Wm are taken for the angular frequency with maximum value of Wms=50*pi rad/s
plt.figure(2)
plt.plot(Wm,inertia_over_torque)
plt.xlabel(r'Angular speed $\omega_m$')
plt.ylabel(' $J/T,1*10^-2$')
plt.title(r'$J/T vs \omega_m$')
plt.grid(True)
x=[6.5,6.5]
y=[2,4.5]
plt.plot(x,y,'blue')
plt.annotate('A',xy=(8,2), xytext=(8,2.1), arrowprops=dict(facecolor='black', shrink=0),)
plt.annotate('B',xy=(8,4.5), xytext=(8,4.6), arrowprops=dict(facecolor='black', shrink=0),)
plt.annotate('C',xy=(80,3.4), xytext=(80,3.5), arrowprops=dict(facecolor='black', shrink=0),)
plt.annotate('D',xy=(157,8.3), xytext=(157,8.4), arrowprops=dict(facecolor='black', shrink=0),)
plt.annotate('E',xy=(157,2), xytext=(157,2.1), arrowprops=dict(facecolor='black', shrink=0),)
plt.show()
print"Hence from the plot the area ABCDEA between the curve and the speed axis for speed change "
print"for synchronous to 0.02 times synchrnous speed is the stopping time is which equal to: 9.36 sec"
```

In [206]:

```
import math
from __future__ import division
#variable declaration
#ratings of the star connected Induction motor
f=50 # frequency in HZ
Vl=2200 # line voltage in V
P=6 # number of poles
#parameters referred to the stator
Xr_=0.5 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=0.12 # resistance of the rotor windings in ohm
Rs=0.075 # resistance of the stator windings in ohm
J=100 # combine inertia of motor and load in kg-m2
#calculation
#(i) during starting of the motor
Sm=Rr_/math.sqrt(Rs**2+(Xs+Xr_)**2) #slip at maximum torque
Wms=4*math.pi*f/P #angular frequency
x=Rs+math.sqrt(Rs**2+(Xs+Xr_)**2)
Tmax=(3/2/Wms)*(Vl/math.sqrt(3))**2/x #maximum torque
tm=J*Wms/Tmax #mechanical time constant of the motor
ts=tm*(1/4/Sm+1.5*Sm) #time taken during starting
Es=1/2*J*Wms**2*(1+Rs/Rr_) #energy disspated during starting
#(ii) when the motor is stopped by plugging method
tb=tm*(0.345*Sm+0.75/Sm) #time required to stop by plugging
Eb=3/2*J*Wms**2*(1+Rs/Rr_) #energy disspated during braking
#(iii)required resistance to be inserted during plugging
tb1=1.027*tm #minimum value of stopping time during braking
x=1.47*(Xs+Xr_) #x=Rr_+Re
Re=x-Rr_ #Re is the required external resistance to be connected
Ee=3/2*J*Wms**2*(Re/(Re+Rr_)) #energy disspated in the external resistor
Eb1=Eb-Ee #total energy disspated during braking
#results
print"(i)Time taken during starting is ts:",round(ts,4),"s"
print" Energy disspated during starting is Es:",round(Es/1000),"kilo-watt-sec"
print"\n(ii)Time taken to stop by plugging is tb:",round(tb,2),"s"
print" Energy disspated during braking is Eb:",round(Eb/1000),"kilo-watt-sec"
print"\n(iii)Minimum Time taken to stop by plugging is tb:",round(tb1,2),"s"
print" Required external resistance to be connected is Re:",round(Re,2),"ohm"
print" Total Energy dissipated during braking is Eb:",round(Eb1/1000,2),"kilo-watt-sec"
```

In [4]:

```
import math
from __future__ import division
import cmath
from sympy import Symbol
from array import array
import numpy as np
#variable declaration
#ratings of the delta connected Induction motor
f=50 # frequency in HZ
Vl=400 # line voltage in V
P=4 # number of poles
Pm=2.8*1000 # rated mechanical power developed
N=1370 # rated speed in rpm
#parameters referred to the stator
Xr_=5 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=5 # resistance of the rotor windings in ohm
Rs=2 # resistance of the stator windings in ohm
Xm=80 # no load reactance
#calculation
Ns=120*f/P #synchronous speed in rpm
Wms=2*math.pi*Ns/60 #synchronous speed in rad/s
s=(Ns-N)/Ns #full load slip
x=(Rs+Rr_/s)**2+(Xs+Xr_)**2 #total impedance
T=(3/Wms)*(Vl**2*Rr_/s)/x #full load torque
Tl=T
K=Tl/(1-s)**2 #since Tl=K*(1-s)**2
#(i) when the motor is running at 1200 rpm
N1=1200 #speed in rpm
s1=(Ns-N1)/Ns #slip at the given speed N1
Tl=K*(1-s1)**2 #torque at the given speed N1
y=(Rs+Rr_/s1)**2+(Xs+Xr_)**2 #total impedance
a=Tl*(Wms/3)*y*(s1/Rr_) #Since T=(3/Wms)*(Vl**2*Rr_/s)/x and a=V**2
V=math.sqrt(a) #required voltage at the given speed N1
Ir_=V/((Rs+Rr_/s1)+1j*(Xs+Xr_))#rotor current
Im=V/(1j*Xm) #magnetizing current
Is=Ir_+Im #total current
Il=abs(Is)*math.sqrt(3) #line current
#(ii)when the terminal voltage is 300 V
V1=300 #terminal voltage in V
s = Symbol('s')
x=(Rs+Rr_/s)**2+(Xs+Xr_)**2
T=(3/Wms)*(V1**2*Rr_/s)/x
#Now we have to solve for the value of slip 's' from the given equation 104s**4- 188s**3 + 89s**2 - 179s + 25=0"
coeff = [104,-188,89,-179,25] #coeffcient of the polynomial equation
s=np.roots(coeff) #roots of the polynomial equation
T=K*(1-s[3].real)**2 #torque at the given terminal voltage of 300 V
N=Ns*(1-s[3].real) #speed at the given terminal voltage of 300 V
Ir_=V1/((Rs+Rr_/s[3].real)+1j*(Xs+Xr_))#rotor current
Im=V1/(1j*Xm) #magnetizing current
Is=Ir_+Im #total current
Il1=abs(Is)*math.sqrt(3) #line current
#results
print"(i)Required torque is Tl:",round(Tl,1),"N-m"
print" Required motor terminal voltage is V:",round(V,1),"V"
print" Required line current is Il:",round(Il,2),"A"
print"\n(ii)The roots of the polynomial equation are "
print" s1:",round(s[0].real,3),"s2:",round(s[1].real,3),"s3:",round(s[2].real,3),"s4:",round(s[3].real,3)
print" Hence Only s4:",round(s[3].real,3),"is valid"
print"\nRequired torque is Tl:",round(T,2),"N-m"
print"Required speed is N:",round(N),"rpm"
print"Required line current is Il:",round(Il1,2),"A"
```

In [1]:

```
import math
from __future__ import division
from array import array
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
#variable declaration
#ratings of the star connected squirrel Induction motor
f=50 # frequency in HZ
Vl=400 # line voltage in V
P=4 # number of poles
N=1370 # rated speed
#the frequency variation is from 10 Hz to 50 Hz
fmin=10
fmax=50
#parameters referred to the stator
Xr_=3.5 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=3 # resistance of the rotor windings in ohm
Rs=2 # resistance of the stator windings in ohm
#calculation
Ns=120*f/P #synchronous speed
N1=Ns-N #increase in speed from no load to full torque rpm
Wms=2*math.pi*Ns/60
s=(Ns-N)/Ns #full load slip
#(i)to obtain the plot between the breakdown torque and the frequency
K=0.1
k=[]
frequency=[]
torque=[]
for i in range (0,9):
K=K+0.1
f1=K*f
x=Rs/K+math.sqrt((Rs/K)**2+(Xs+Xr_)**2)
Tmax=(3/2/Wms)*(Vl/math.sqrt(3))**2/x
k.append(round(K,1))
frequency.append(round(f1))
torque.append(round(Tmax,2))
print"K :",k
print"f :",frequency,"Hz"
print"Tmax :",torque,"N-m"
#plotting the values of Tmax vs f
plt.figure(1)
plt.plot(frequency,torque,'y')
plt.xlabel('$f$,Hz')
plt.ylabel('$Tmax$,N-m')
plt.grid(True)
plt.title('Torque vs frequency characteristic')
plt.show()
#(ii) to obtain the starting torque and current at rated frequency and voltage
x=(Rs+Rr_)**2+(Xs+Xr_)**2
Tst=(3/Wms)*(Vl/math.sqrt(3))**2*Rr_/x #starting torque at 50 Hz frequency
Ist=(Vl/math.sqrt(3))/math.sqrt(x) #starting current at 50 Hz frequency
K=fmin/fmax #minimum is available at 10 Hz
y=((Rs+Rr_)/K)**2+(Xs+Xr_)**2
Tst_=(3/Wms)*(Vl/math.sqrt(3))**2*Rr_/K/y #starting torque at 10 Hz frequency
Ist_=(Vl/math.sqrt(3))/math.sqrt(y) #starting current at 10 Hz frequency
ratio1=Tst_/Tst #ratio of starting torque to the rated starting torque
ratio2=Ist_/Ist #ratio of starting current to the rated starting current
#results
print"\n(i)Hence from the plot we can see that for a constant (V/f) ratio breakdown torque decreases with frequency"
print"\n(ii)Hence the required ratio of starting torque to the rated starting torque is :",round(ratio1,3)
print" Hence the required ratio of starting current to the rated starting current is :",round(ratio2,2)
```

In [209]:

```
import math
from __future__ import division
from array import array
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
#variable declaration
#ratings of the star connected squirrel Induction motor is same as that of Ex-6.9
f=50 # frequency in HZ
Vl=400 # line voltage in V
P=4 # number of poles
N=1370 # rated speed
#the frequency variation is from 5 Hz to 50 Hz
fmin=5
fmax=50
#parameters referred to the stator
Xr_=3.5 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=3 # resistance of the rotor windings in ohm
Rs=2 # resistance of the stator windings in ohm
#calculation
Ns=120*f/P #synchronous speed
N1=Ns-N #increase in speed from no load to full torque rpm
Wms=2*math.pi*Ns/60
s=(Ns-N)/Ns #full load slip
Tmax=torque[8] #maximum torque as obtain from Ex-6.9
#to obtain the plot between the voltage and the frequency
K=0
k=[]
frequency=[]
line_voltage=[]
for i in range (0,10):
K=K+0.1
f1=K*f
x=2*K*Wms*Tmax/3
y=Rs+math.sqrt((Rs)**2+(K*(Xs+Xr_))**2)
Vl_square=3*x*y
Vl=math.sqrt(Vl_square)
k.append(round(K,1))
frequency.append(round(f1))
line_voltage.append(round(Vl,1))
print"K :",k
print"f :",frequency,"Hz"
print"Vl :",line_voltage,"V"
#plotting the values of line voltage Vl vs f
plt.figure(1)
plt.plot(frequency,line_voltage,'b')
plt.xlabel('$f$,Hz')
plt.ylabel('Line voltae,volts')
plt.grid(True)
plt.title('Line voltage vs frequency characteristic')
#for constant V/f ratio
x=[0,10,20,30,40,50]
y=[0,80,160,240,320,400]
plt.plot(x,y,'--')
plt.annotate('Constant V/f ratiuo', xy=(21, 160), xytext=(30, 160),arrowprops=dict(facecolor='black', shrink=0),)
plt.show()
print"\nHence for a constant breakdown torque at all frequencies,"
print"V/f ratio has to be progressively increased with increase in frequency"
```

In [210]:

```
import math
from __future__ import division
#variable declaration
#ratings of the star connected squirrel Induction motor is same as that of Ex-6.9
f=50 # frequency in HZ
Vl=400 # line voltage in V
P=4 # number of poles
N=1370 # rated speed
#parameters referred to the stator
Xr_=3.5 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=3 # resistance of the rotor windings in ohm
Rs=2 # resistance of the stator windings in ohm
#calculation
Ns=120*f/P #synchronous speed
N1=Ns-N #increase in speed from no load to full torque rpm
Wms=2*math.pi*Ns/60 #synchronous speed
s=(Ns-N)/Ns #full load slip
D=Ns-N #drop in speed from no load to full load torque at 50 Hz
#(i)when the frequency is 30 Hz and 80% of full load torque
f1=30 #given frequency in Hz
d=D*0.8 #drop in speed from no load to 80% full load torque
Ns1=120*f1/P #synchronous speed at the given frequency f1=30 Hz
N1=Ns1-d #required motor speed
#(ii)when the speed is 1000 rpm for a full load torque
N2=1000 #given speed in rpm
Ns2=N2+D #synchronous speed
f2=P*Ns2/120 #required frequency
#when the speed is 1100 rpm and the frequency is 40 Hz
N3=1100 #given speed in rpm
f3=40 #given frequency in Hz
Ns3=120*f3/P #synchronous speed at the given frequency f1=40 Hz
D1=Ns3-N3 #drop in speed from no load to N1=1100 rpm
x=(Rs+Rr_/s)**2+(Xs+Xr_)**2
Tf=(3/Wms)*(Vl/math.sqrt(3))**2*(Rr_/s)/x #full load torque
T1=D1/D*Tf #required torque
#results
print"(i)Hence the required motor speed is :",round(N1),"rpm"
print"\n(ii)Hence the required frequency is :",round(f2,2),"Hz"
print"\n(iii)Hence the required torque is :",round(T1,2),"N-m"
```

In [211]:

```
import math
from __future__ import division
#variable declaration
#ratings of the star connected Induction motor is same as that of Ex-6.9
f=50 # frequency in HZ
Vl=400 #line voltage in V
P=4 # number of poles
N=1370 #rated speed
#parameters referred to the stator
Xr_=3.5 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=3 # resistance of the rotor windings in ohm
Rs=2 # resistance of the stator windings in ohm
#calculation
Ns=120*f/P #synchronous speed
N1=Ns-N #increase in speed from no load to full torque rpm
#(i)when f1=30Hz and 80% of full load
Ns=120*f/P
f1=30 #frequency
N2=0.8*N1 #increase in speed from no load to 80% of full torque rpm
Ns1=f1/f*Ns
N=Ns1+N2 #machine speed
#(ii)at a speed of 1000rpm
N2=1000 #given speed in rpm
N3=N2-N1 #synchronous speed
f3=P*N3/120 #required frequency
#(iii)when frequency is 40Hz and speed is 1300 rpm
f4=40 #frequency in hz
N2=1300 #speed in rpm
Ns=120*f4/P #required synchronous speed in rpm
N4=N2-Ns #increase in speed from no load speed in rpm
Tf=25.37 #full load torque as calculated in Ex-6.11
Tm=-N4/N1*Tf #motor torque
#(iv) when the motor is under dynamic braking
#results
print"(i)Required speed is :",N,"rpm"
print"\n(ii)required frequency is:",f3,"Hz"
print"\n(iii)Required motor torque :",round(Tm,2),"N-m"
print"\n(iv)The value of the frequency,speed and motor torque calculated in (i),(ii) and(iii)"
print" will be the same when the motor is operated under dynamic braking"
```

In [212]:

```
import math
from __future__ import division
#variable declaration
#ratings of the star connected Induction motor is same as that of Ex-6.9
f=50 # frequency in HZ
Vl=400 #line voltage in V
P=4 # number of poles
N=1370 #rated speed
#parameters referred to the stator
Xr_=3.5 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=3 # resistance of the rotor windings in ohm
Rs=2 # resistance of the stator windings in ohm
#calculation
Wms=4*math.pi*f/P
f1=60 #frequency in Hz during speed control of the motor
K=f1/f #the value of K at 60Hz
x=Rs+math.sqrt(Rs**2+K**2*(Xs+Xr_)**2)
Tmax_=3/(2*K*Wms)*(Vl/math.sqrt(3))**2/x #torque at 60 Hz frequency
z=Rs+math.sqrt(Rs**2+(Xs+Xr_)**2)
Tmax=3/(2*Wms)*(Vl/math.sqrt(3))**2/z #maximum torque
ratio=Tmax_/Tmax #ratio
#results
print"Ratio of Motor breakdown torque at 60Hz to rated torque at 50Hz is:",round(ratio,3)
```

In [213]:

```
import math
from __future__ import division
print"When operating at a frequency K times rated frequency f then"
print"Im**2=[((Rr_/Ksf)**2+(2*pi*Lr_)**2)/((Rr_/Ksf)**2+(2*pi*Lm+2*Pi*Lr_)**2)]*Is**2----(1)"
print"Since Im is constant for constant flux therefore"
print"K*s*f=constant--------(2)"
print"K*Wms*s=constant-------(3) which is the slip speed"
print"s*K=constant----------(4)"
print"Thereofre for a frequency K*f"
print"T=(3/K/Wms)*[(Is*K*Xm)**2*(Rr_/s)/((Rr_/s)**2+K**2*(Xm+Xr_)**2]"
print"T=(3/K/Wms*s)*[(Is*Xm)**2*(Rr_)/((Rr_/s/K)**2+(Xm+Xr_)**2]-------(5)"
print"\nHence for a given slip speed (K*Wms*s),K*s is constant and from (1) for a given K*s*f and constant flux"
print"operation Is is fixed. Now from (5) T is also fixed. Thus, motor develps a constant torque and draws a"
print"constant current from the inverter at all frequencies for a given slip speed"
```

In [214]:

```
import math
from __future__ import division
#variable declaration
#ratings of the star connected Induction motor
f=50 # frequency in HZ
Vl=400 #line voltage in V
P=4 # number of poles
N=1370 #rated speed
#parameters referred to the stator
Xr_=3.5 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=3 # resistance of the rotor windings in ohm
Rs=2 # resistance of the stator windings in ohm
Xm=55 # magnetizing reactance in ohm
#calculation
Ns=120*f/P #synchronous speed in rpm
s=(Ns-N)/Ns #full load slip
x=1j*Xm*(Rr_/s+1j*Xr_)
y=Rr_/s+1j*(Xr_+Xm)
Z=Rs+1j*Xs+x/y #total motor impedance
Isf=(Vl/math.sqrt(3))/abs(Z) #full load stator current
Irf_=Isf*(1j*Xm)/(Rr_/s+1j*(Xr_+Xm)) #full load rotor current
Tf=(3/Wms)*abs(Irf_)**2*Rr_/s #full load torque
N1=Ns-N #full load slip speed
#(i) when the motor is operating at 30Hz
f1=30 #given frequency in Hz
#at rated slep speedvalue of torque and stator current is same as the rated value
T=Tf
Is=abs(Isf)
Ns1=f1/f*Ns #synchronous at f1=30Hz
N2=Ns1-N1 #required motor speed at 30Hz
#(ii)at a speed of 1200 rpm
N3=1200 #speed in rpm
Ns1=N3+N1 #required synchronous speed
f1=Ns1/Ns*f #required frequency at N2=1200rpm
#(iii)when speed-torque curves are assumed to be straight lines at 30Hz at half the rated motor torque
f2=30 #frequency in Hz
N1_=N1/2 #slip at half the rated torque
Ns1=f2/f*Ns #synchronous at f1=30Hz
N4=Ns1-N1_ #required motor speed
#(iv) When the motor is operating at 45hz and braking torque is equal to rated torque
f3=45 #given frequency in Hz
N1_=-N1 #slip speed when braking at rated torque
Ns1=f3/f*Ns #synchronous at f1=45Hz
N5=Ns1-N1_ #required motor speed
#results
print"(i)At 30Hz the required value of Torque is T:",round(T,2),"N-m "
print" Stator current is Is:",round(Is,4),"A"
print" Motor speed is :",N2,"rpm"
print"\n(ii)Required inverter frequency is :",round(f1,2),"Hz"
print"\n(iii)Required motor speed at 30Hz is:",N4,"rpm"
print"\n(iv)Required motor speed at 45Hz is:",N5,"rpm"
```

In [217]:

```
import math
import cmath
from __future__ import division
#variable declaration
#ratings of the Delta connected slipring Induction motor
f=50 # frequency in HZ
Vl=400 #line voltage in V
P=6 # number of poles
SR=2.2 #ratio of stator to rotor
#parameters referred to the stator
Xr_=1 # rotor winding reactance in ohm
Rr_=0.2 # resistance of the rotor windings in ohm
s=0.04 # given slip when motor runs at full load
#calculation
Ns=120*f/P #synchronous speed
Wms=2*math.pi*Ns/60
x=(Rr_/s)**2+Xr_**2
Tf=(3/Wms)*(Vl)**2*(Rr_/s)/x #full load torque
K=Tf/(Ns*(1-s))**2
N=850 #speed of the motor in rpm
Tl=K*N**2 #torque at the given speed N
s=(Ns-N)/Ns #slip at the given speed N
y=Tl*(Wms/3)/Vl**2 #y=X/(X**2+Xr_**2) and X=(Re+Rr_)/s
print"The torque at the given speed of 850rpm is:",round(Tl),"N-m"
print"With a slip of s:",s
print"To find the external resistance connected the given quadratic equation is X**2-6.633X+1=0"
print"With X=(Re-Rr_)/s where Re is the required external resistance"
a = 1
b = -1/y
c = 1
# calculate the discriminant
d = (b**2) - (4*a*c)
# find two solutions
X1 = (-b-cmath.sqrt(d))/(2*a)
X2 = (-b+cmath.sqrt(d))/(2*a)
#results
print"The solution for X are ",round(X1.real,4),"and",round(X2.real,4)
Re1=X1*s-Rr_
Re2=X2*s-Rr_
if (Re1.real>0) :
print"\nThe number Re1:",round(abs(Re1),3),"ohm is feasible:"
R=Re1.real/SR**2
print"Rotor referred value of the external resistance is:",round(R,3),"ohm"
if (Re2.real>0) :
print"\nThen Re2:",round(abs(Re2),3),"ohm is feasible"
R=Re2.real/SR**2
print"Hence Rotor referred value of the external resistance is:",round(R,3),"ohm"
```

In [7]:

```
import math
from __future__ import division
from sympy import Symbol
#variable declaration
#ratings of the star connected Induction motor
f=50 # frequency in HZ
Vl=440 #line voltage in V
P=6 # number of poles
Ns=120*f/P #synchronous speed
#parameters referred to the stator
Xr_=1.2 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=0.4 # resistance of the rotor windings in ohm
Rs=0.5 # resistance of the stator windings in ohm
Xm=50 # magnetizing reatance
a=3.5 # stator to rotor turns ratio
delta=0 # duty ratio at the given breakdown torque
Sm=1 # slip at standstill
#calculation
#slip at maximum torque without an external resistance is Sm=Rr_/math.sqrt(Rs**2+(Xs+Xr_)**2)
#when an external resistanc Re referred to the stator is connected
x=Sm*math.sqrt(Rs**2+(Xs+Xr_)**2) #x=Re+Rr_
Re=x-Rr_
y=0.5*a**2*(1-delta) # y=0.5*a**2*R*(1-delta) #y=Re
R=Re/y
N = Symbol('N')
Sm=(Ns-N)/Ns
c=(x*Sm-Rr_)/(0.5*a**2*R) #c=(1-delta)
delta=1-c #given duty ratio
#results
print"variation of the duty ratio is",round(delta*1000/N,3),"*N*10**(-3)"
print"Hence the duty ratio must change linearly with speed N"
```

In [219]:

```
import math
from __future__ import division
import cmath
#variable declaration
#ratings of the star connected Induction motor
f=50 # frequency in HZ
Vl=440 # line voltage in V
P=6 # number of poles
N=970 # rated speed
n=2 # ratio of stator to rotor
Sm=0.25 # it is given the speed range is 25% below the synchronous speed which is proportional to the Slip
#parameters referred to the stator
Xr_=0.4 # rotor winding reactance in ohm
Xs=0.3 # stator winding reactance in ohm
Rr_=0.08 # resistance of the rotor windings in ohm
Rs=0.1 # resistance of the stator windings in ohm
alpha=165 # maximum value of the firing angle in degress
#calculation
Ns=120*f/P # synchronous speed
Wms=2*math.pi*Ns/60
#(i) transformer turns ratio
a=-Sm/math.cos(math.radians(alpha)) #since Sm=a*math.cos(alpha)
m=n/a #since a=n/m where m is the transformer ratio
#(ii)When speed is 780 rpm and firing angle is 140 degrees
N1=780 #given speed
alpha1=140 #given firing angle
s1=(Ns-N1)/Ns #slip at the given speed N1
Vd1=(3*math.sqrt(6)/math.pi)*s1*(Vl/math.sqrt(3))/n
Vd2=(3*math.sqrt(6)/math.pi)*(Vl/math.sqrt(3))/m*math.cos(math.radians(alpha1))
Rs_=Rs*(1/n)**2 #stator resistance referred to the rotor
Rr=Rr_*(1/n)**2 #rotor resistance referred to the rotor
Rd=0.01 #equivalent resistance of the DC link inductor
Id=(Vd1+Vd2)/(2*(s1*Rs_+Rr)+Rd)
T1=abs(Vd2)*Id/s1/Wms #required torque
#(iii)when speed is 800rpm and firing angle is half the rated motor torque
N1=800 #given speed
s=(Ns-N)/Ns #rated slip
x=(Rs+Rr_/s)**2+(Xs+Xr_)**2
Trated=(3/Wms)*(Vl/math.sqrt(3))**2*(Rr_/s)/x #rated torque
T_half=Trated/2 #half rated torque
s1=(Ns-N1)/Ns #given slip at speed N1=800rpm
Vd1=(3*math.sqrt(6)/math.pi)*s1*(Vl/math.sqrt(3))/n
cos_alpha1 = Symbol('cos_alpha1')
Vd2=(3*math.sqrt(6)/math.pi)*(Vl/math.sqrt(3))/m*cos_alpha1
Id=(Vd1+Vd2)/(2*(s1*Rs_+Rr)+Rd)
T=abs(Vd2)*Id/s1/Wms #required torque
#let cos_alpha1=-X
X=-cos_alpha1
#since the given torque is half of the rated value
#To find the find the firing angle we assumed cos(alpha1)=-X
#The given quadratic equation is X**2-0.772X+0.06425=0
a = 1
b = -0.772
c = 0.06425
# calculate the discriminant
d = (b**2) - (4*a*c)
# find two solutions
X1 = (-b-cmath.sqrt(d))/(2*a)
X2 = (-b+cmath.sqrt(d))/(2*a)
alpha1=-math.acos(X2.real) #since cos(alpha1)=-X where alpha1 is radians
alpha1=math.degrees(alpha1) #angle in degrees
alpha1=180+alpha1 #required firing angle
#results
print"(i)Transformer ratio is: ",round(m,3)
print"\n(ii)Required torque is :",round(T1),"N-m"
print" There is a slight difference in the answer for the torque due to accuracy i.e more number of decimal place"
print"\n(iii)The half rated torque at the given speed of",N1,"rpm is:",round(T_half,2),"N-m"
print" With a slip of s:",s1
print"The solution for X are ",round(X1.real,4),"and",round(X2.real,4)
print"For X1:",round(X1.real,4)," the motor is unstable hence we discard this value and we use X2:",round(X2.real,4)
print"\nHence the required firing angle is :",round(alpha1,1),"°"
```

In [220]:

```
import math
from __future__ import division
import cmath
#variable declaration
#ratings of the star connected Induction motor is same as that of Ex-6.17
f=50 # frequency in HZ
Vs=440 # line voltage in V
P=4 # number of poles
#parameters referred to the stator
Xr_=1.2 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=0.4 # resistance of the rotor windings in ohm
Rs=0.5 # resistance of the stator windings in ohm
Xm=50 # magnetizing reatance
a=3.5 # stator to rotor turns ratio
#calculation
Ns=120*f/P # synchronous speed in rpm
Wms=2*math.pi*Ns/60 # synchronous speed in rad/s
#(i)when motor speed is 1200rpm with a voltage of 15+0j V
V=cmath.rect(15,0)
N1=1200 #speed in rpm
Vr_=a*V #rotor voltage
s1=(Ns-N1)/Ns #slip at the given speed N1=1200 rpm
Z=Rs+Rr_/s1+1j*(Xs+Xr_) #total impedance
Ir_=(Vs/math.sqrt(3)-Vr_/s1)/Z #rotor current
phi_r=cmath.phase(Vr_)-cmath.phase(Ir_) #angle between Vr_ and Ir_
Pr=3*(abs(Ir_))**2*Rr_ #rotor copper loss
P1=3*abs(Vr_)*abs(Ir_)*math.cos(phi_r) #power absorbed by Vr_
Pg=(Pr+P1)/s1 #gross power
T=Pg/Wms #required motor torque
#(ii)when motor speed is 1200rpm with a unity power factor
N1=1200 #speed in rpm
Ir_=cmath.rect(abs(Ir_),0) #machine is operating at unity power factor
x=Ir_*Z #x=(Vs-Vr_/s1)*phi_r where phi_r is the angle between Vr_ and Ir_
#x=a+b
d=(Vs/math.sqrt(3)-Vr_/s1*math.cos(phi_r))**2
e=(Vr_/s1*math.sin(phi_r))**2
f=x/(d+e)
theta=cmath.phase(f) #required angle in radian
#Now we should solve for the quadratice equation for the rotor current
# 0.9*Ir_**2 + 50.8*Ir_ + 90.12 = 0
a1 = 0.9
b1 = 50.8
c1 = 90.12
# calculate the discriminant
d = (b1**2) - (4*a1*c1)
# find two solutions
Ir_1 = (-b1-cmath.sqrt(d))/(2*a1)
Ir_2 = (-b1+cmath.sqrt(d))/(2*a1)
Ir_=Ir_2 #Ir_2 is chosen because for Ir_1 the motor is unstable
Vr_sin_phi_r=abs(Ir_)/2.083
Vr_cos_phi_r=s1*(Vs/math.sqrt(3)+2.5*Vr_sin_phi_r)
Vr_=Vr_cos_phi_r+1j*Vr_sin_phi_r #total rotor voltage referred to the stator
Vr_=Vr_/a #total rotor voltage referred to the rotor
phase=round(math.degrees(cmath.phase(Vr_))) #required phase of the voltage in degrees
#results
print"(i)The torque is :",round(T,2),"N-m and since it is negative the motor is operating in regenerative braking "
print"\n(ii)Now theta θ:",round(math.degrees(theta),2),"◦"
print" The solution for Ir_ are ",round(Ir_1.real,3),"and",round(Ir_2.real,3)
print" We choose Ir_:",round(Ir_2.real,3),"A since higher value corresponds to unstable region"
print"\n Hence the required voltage magnitude is Vr:",round(abs(Vr_),2),"V",";phase:",phase,"◦"
print"\n Note :There is a slight difference in the answers due to accuracy i.e more number of decimal place"
```

In [221]:

```
import math
from __future__ import division
import cmath
#variable declaration
#ratings of the single phase Induction motor
f=50 # frequency in HZ
Vs=220 # supply voltage in V
P=4 # number of poles
N=1425 # rated speed in rpm
#parameters referred to the stator
Xr_=6 # rotor winding reactance in ohm
Xs=Xr_ # stator winding reactance in ohm
Rr_=5 # resistance of the rotor windings in ohm
Rs=2 # resistance of the stator windings in ohm
Xm=60 # magnetizing reatance
#calculation
N1=1200 #when the motor is operating at the given speed in rpm
Ns=120*f/P # synchronous speed
Wms=2*math.pi*Ns/60
s=(Ns-N)/Ns #rated slip
Zf=1j*(Xm)*(Rr_/s+1j*Xr_)/2/(Rr_/s+1j*(Xr_+Xm))
Rf=Zf.real ; Xf=Zf.imag
Zb=1j*(Xm)*(Rr_/(2-s)+1j*Xr_)/2/(Rr_/(2-s)+1j*(Xr_+Xm))
Rb=Zb.real ; Xb=Zb.imag
Zs=Rs+1j*Xs
Z=Zs+Zf+Zb
Is=(Vs)/Z
T=(abs(Is))**2/Wms*(Rf-Rb)
Tl=T
K=Tl/N**2
#therefore for a speed of of N1=1200 rpm we get
Tl=K*N1**2 #required load torque for the given speed N1
s1=(Ns-N1)/Ns # slip for the given speed N1
Zf=1j*(Xm)*(Rr_/s1+1j*Xr_)/2/(Rr_/s1+1j*(Xm))
Rf=Zf.real ; Xf=Zf.imag
Zb=1j*(Xm)*(Rr_/(2-s1)+1j*Xr_)/2/(Rr_/(2-s1)+1j*(Xr_+Xm))
Rb=Zb.real ; Xb=Zb.imag
x=(Wms*Tl)/(Rf-Rb) #since Tl=(abs(Is))**2/Wms*(Rf-Rb) and x=Is**2
Is=math.sqrt(x)
Z=Zs+Zf+Zb
V=Is*abs(Z)
#results
print"Hence the motor terminal voltage at the speed of",N1,"rpm is : ",round(V,1),"V"
```