# Chapter 5: Synchronous Machines¶

### Example 5.1, Page number: 254¶

In [2]:
from __future__ import division
import math
import cmath

#Varaible Declaration:
pf=0.95                                 #Lagging power factor
Vl=460                                  #Terminal voltage(V)
I=120                                   #Terminal current(A)
If=47                                   #Field current(A)
X=1.68j                                 #Line syncchronous reactance(ohm)

#Calculation:
#Choosing motor reference direction:
Va=Vl/math.sqrt(3)
theta=math.acos(0.95)
Ia=I*cmath.exp(-theta*1j)
Eaf=Va-X*Ia
wc=120*math.pi
Laf=math.sqrt(2)*abs(Eaf)/(wc*If)
P=3*Va*Ia*pf

#Results:
print "Generated emf:",round(abs(Eaf),1),"V line to line"
print "Fied to armature mutual inductance:",round(Laf*1000,1),"mH"
print "Three phase power:",round(abs(P/1000),1),"kW or",round(abs(P)/746),"hp"

Generated emf: 278.8 V line to line
Fied to armature mutual inductance: 22.3 mH
Three phase power: 90.8 kW or 122.0 hp


### Example 5.2, Page number: 255¶

In [4]:
from __future__ import division
import cmath
from math import *

#Variable Declaration:
Pin=90.6*10**3                              #Input power(kW)
Va=265.6                                    #Terninal voltage(V)
X=1.68j                                     #Synchronous reactance(ohm)
Laf=22.3*10**-3                             #Mutual inductance(H)

#Calculations:
Ia=Pin/(3*Va)
Eaf=Va-X*Ia
delta=degrees(cmath.phase(Eaf))
I=sqrt(2)*Eaf/(wc*Laf)

#Results:
print"The phase angle,delta:",round(delta,1),"degrees"
print"Required field current:",round(abs(I),2),"A"

The phase angle,delta: -35.7 degrees
Required field current: 55.04 A


### Example 5.3, Page number: 257¶

In [5]:
from __future__ import division
from math import *

#Variable declaration:
Eafl=13.8*10**3                             #Open circuit voltage(V)
If1=318                                     #Field current(A)
If2=263                              #Field current after extrapolation(A)
wc=120*pi                            #Angular frequency(Hz)

#Calculations:
Eaf=Eafl/sqrt(3)
La1=sqrt(2)*Eaf/(wc*If1)
La2=sqrt(2)*Eaf/(wc*If2)

#Results:
print "Saturated Laf1:",round(La1*1000,0),"mH"
print "Unsaturated Laf1:",round(La2*1000,0),"mH"

Saturated Laf1: 94.0 mH
Unsaturated Laf1: 114.0 mH


### Example 5.4, Page number: 262¶

In [6]:
from __future__ import division
from math import *

#Variable declaration:
Ia=[118, 152]                     #Armature current from SC Characteristics(A)
If=[2.20, 2.84]                     #Field current from SC Characteristics(A)
Vll=220                             #Line-to-line Voltage(V)
V=202                               #Line-to-line air voltage(V)
P=45*10**3                          #Power roted to motor(W)
Is_sc=1                             #per unit rated current(A)

#Calculations:
Va_ag=V/sqrt(3)                 #At field current of 2.20A,at air gap,(V)
Ia_ag=Ia[0]
Xs_u=Va_ag/Ia_ag
Ia_rated=P/(sqrt(3)*Vll)
Xa_g=Va_ag/1
Xs_u_pu=Va_ag/Is_sc
Xs=Vll/(Ia[1]*sqrt(3))
Ia_pu=Ia[1]/Ia[0]
SCR=If[1]/If[0]
Xs=1/SCR

#Results:
print "'All quantities are in per unit values'"
print"Unsaturated value of synchronous reactance:",round(Xs_u,3),"ohm"
print "Satureted value of synchronous reactance: ",round(Xs,3),"ohm"
print"Short circuit ratio:",round(SCR,3)

'All quantities are in per unit values'
Unsaturated value of synchronous reactance: 0.988 ohm
Satureted value of synchronous reactance:  0.775 ohm
Short circuit ratio: 1.291


### Example 5.5, Page number: 265¶

In [4]:
from __future__ import division

#Variable declaration:
P_rated=45*10**3                        #Rated power(KV)
Ia_pu=1                                    #Per unit armature current
Ia=118                                  #rated armature current(A)
Ra_dc=0.0335                            #Dc resistance(ohm/phase)

#Calculations:
Pl_pu=Pl/P_rated
Ra_eff1=Pl_pu/Ia_pu**2                      #in per unit basis
Ra_eff2=Pl/(3*(Ia)**2)

#Results:
print "Armature resistance in per unit:",round(Ra_eff1,3),"per unit"
print "Armature resistance in ohms/phase:", round(Ra_eff2,3),"ohms/phase"

Armature resistance in per unit: 0.04 per unit
Armature resistance in ohms/phase: 0.043 ohms/phase


### Example 5.6, Page number: 269¶

In [1]:
from __future__ import division
%matplotlib inline
import cmath
import math
from pylab import *

#Variable declaration:
Veq=1.0                                 #Externalsupply(p.u)
Eaf=1.0                                 #Internal voltage(p.u)
Xeq=0.23                                #Eqv.resistance of external system(p.u)
Xs=1.35                                #Saturated synchronous reactance(p.u)

#Calculations:
#for part (a):
P_max=Eaf*Veq/(Xs+Xeq)

#for part (b):
delta=[0]*500
Ia=[0]*500
Va=[0]*500
degree=[0]*500
for n in range(1,101,1):
delta[n-1]=(pi/2)*(n-1)/100
Ia[n-1] = (Eaf *exp(1j*delta[n-1]) - Veq)/(1j*(Xs + Xeq))
Va[n-1] = abs(Veq + 1j*Xeq*Ia[n-1])
degree[n-1]=180*delta[n-1]/pi
plot(degree,Va,'r.')
xlabel('Power angle,delta(degrees)')
ylabel('Terminal voltage(per unit)')
title('Terminal voltage vs. power angle for part (b)')
show()
#for part (c):
Vterm=1.0
P=[0]*500
deltat=[0]*500
Ia=[0]*500
Eaf=[0]*500

for n in range(1,101,1):
P[n-1]=(n-1)/100
deltat[n-1]=math.asin(P[n-1]*Xeq/(Vterm*Veq))
Ia[n-1]=(Vterm*exp(1j*deltat[n-1])-Veq)/(1j*Xeq)
Eaf[n-1]=abs(Vterm+1j*(Xs+Xeq)*Ia[n-1])
plot(P,Eaf,'r.')
xlabel('Power [per unit]')
ylabel('Eaf [per unit]')
title('Eaf vs. power for part (c)')
show()

#Results:
print "(a) Maximum power supplied to external system:",round(P_max,2),"p.u"

(a) Maximum power supplied to external system: 0.63 p.u


### Example 5.7, Page number: 272¶

In [8]:
from __future__ import division
from math import *

#Variable declaration:
P_rated=2000*746/3                     #per phase rated power of motor(W)
Xsm=1.95                                #Synchronous reactance(ohm)
Vl=2300                                #Line to line voltage(V)
f=60                                   #Angular frequency(Hz)
p=30                                   #No. of poles
Xsg=2.65                               #Synchronous reactance of generator(ohm)

#Calculations:
#for part (a):
Vp=2300/sqrt(3)
Ip=P_rated/Vp
Eafm=sqrt(Vp**2+(Ip*Xsm)**2)
Pm=3*Vp*Eafm/Xsm                             #Max power delivered to motor(W)
ws=2*2*pi*f/p
Tmax=Pm/ws                                  #MAx torque of motor(Nm)

#for part (b):
Eafg=sqrt(Vp**2+(Ip*Xsg)**2)
Pm2=3*Eafm*Eafg/(Xsg+Xsm)                   #Max power delivered to motor(W)
Tmax2=Pm2/ws                                #Max torque(Nm)

#Results:
print"(a) Max power  :",round(Pm/1000,0),"kW,3-ph"
print"    Max torque :",round(Tmax/1000,1),"kNm"
print "(b) Max power :", round(Pm2/1000,0),"kW,3-ph"
print "    Max torque:", round(Tmax2/1000,1),"Nm"

(a) Max power  : 3096.0 kW,3-ph
Max torque : 123.2 kNm
(b) Max power : 1639.0 kW,3-ph
Max torque: 65.2 Nm


### Example 5.8, Page number: 279¶

In [9]:
from __future__ import division
from math import *

#Variable declaration:
P=45                                    #Power rated(KVA)
Va=220                                  #Terminal voltage(V)
Pin=45                                  #Power input to the armature(KVA)
If=5.50                                 #field current(A)
Rf=35.5                                 #Field winding resistance(ohm)
Ra=0.0399                               #Armature dc resistance(ohm/phase)
Xal=0.215                               #Leakage reactance of motor(ohm)
pf=0.80                                 #Lagging power factor
Pc=1.8                                  #Core loss(kW)
Pw=0.91                                 #Friction & windage losses(kW)

#Calculations:
Ia=P*10**3/(sqrt(3)*Va)
P1=If**2*Rf/10**3                            #Loss in field winding(kW)
P2=3*Ia**2*Ra/10**3                          #Loss in armature(kW)
Pl=(Pc+Pw+Ps+P1+P2)
Pi=Pin*pf+P1
Po=Pi-Pl
eff=(Po/Pi)*100

#Results:
print "Efficiency of the synchronous machine:",round(eff,1),"%"

Efficiency of the synchronous machine: 84.3 %


### Example 5.9, Page number: 287¶

In [12]:
from __future__ import division
import math
import cmath

#Variable declaration:
Xd=1                              #Direct axis synchronus reactance(p.u)
Va=1                              #Terminal voltage(p.u)
pf=0.8                              #Lagging power factor
Ia=0.8-1j*math.sin(math.acos(0.8))       #Line current(p.u)

#Calculations:
phy=-math.acos(pf)
E=Va+1j*Xq*Ia
delta=cmath.phase(E)
Id=abs(Ia)*math.sin(delta-phy)*cmath.exp(1j*(-pi/2+delta))
Iq=abs(Ia)*math.cos(delta-phy)*cmath.exp(1j*delta)
Eaf=Va+Xd*Id*1j+Xq*Iq*1j

#Results:
print "Generated voltage:",round(abs(Eaf),2),"p.u Volt"

Generated voltage: 1.78 p.u Volt


### Example 5.11, Page number: 291¶

In [1]:
from pylab import *
import cmath
from sympy import *

#Variable declaration:
P_rated=2000*746                  #Rated power of motor(W)
Xs=1.95                           #Synchronous reactance(ohm/phase)
Xd=1.95                           #Direct axis synchronous reactance(ohm/ph)
pf=1                            #Power factor of the machine
Vl=2300                         #Line to line voltage(V)

#Calculatons:
Va=float(Vl/sqrt(3))              #volt
Ia=float(P_rated/(Va*3))          #ampere
E1=Va-1j*Ia*Xq                      #From phasor diagram
delta=cmath.phase(E1)             #power angle
Id=Ia*sin(abs(delta))             #direct axis current(A)
Eaf=abs(E1)+Id*(Xd-Xq)
r=symbols('r')
def P(r):                           #Process for finding maximum power
return Eaf*Va*sin(r)/Xd + Va**2*(Xd-Xq)*sin(2*r)/(2*Xd*Xq)
P1=diff(P(r),r)
#On differentiation,
#P1 = 1023732.58489791*cos(r) + 355250.305250306*(2*(cos(r))**2-1)
l = solve(1023732.58489791*cos(r) + 355250.305250306*(2*(cos(r))**2-1),r)
P_max = (P(round(l[0],5)))

#Results:
print "Maximum mechanical power:",math.ceil(3*P_max/10**3),"kW,3-phase"

Maximum mechanical power: 3236.0 kW,3-phase