Chapter 08 : Synchronous Machines

Example 8.2, Page No 148

In [2]:
import math
#initialisation of variables
#to determine voltage regulation by mmf method

  
pf=0.85 
P=150*10**6 
V=13*1000.0

#Calculations
Iarated=P/(math.sqrt(3)*pf*V) 
If=750 
Ifocc=810 
B=math.degrees(math.acos(pf))
Ff=math.sqrt((Ifocc+If*math.sin(math.radians(B)))**2+(If*math.cos(math.radians(B)))**2) 
Ef=16.3*1000 
vr=Ef/V-1

#Results
print(vr*100,'voltage regulation(%)') 

(25.384615384615383, 'voltage regulation(%)')

Example 8.6, Page No 149

In [3]:
import math
#initialisation of variables
#to calculate the excitation emf

  
Vt=3300.0 
Xs=18/3.0 
pf=.707 
P=800*1000 

#Calculations
Ia=P/(math.sqrt(3)*Vt*pf) 
a=Ia*Xs/math.sqrt(2) 
b=Vt/math.sqrt(3.0) 
Ef=math.sqrt((a+b)**2+a**2)*math.sqrt(3.0)

#Results
print(Ef,'excitation emf(V)(line)') 

(4972.3367904266, 'excitation emf(V)(line)')

Example 8.7, Page No 149

In [6]:
import math
#initialisation of variables

#to compute the max power and torque,terminal voltage

  
V=3300.0 
Vt=V/math.sqrt(3) 
P=1000*10**3 
pf=1 
Ia=P/(V*math.sqrt(3)*pf) 
Xsm=3.24 
j=math.sqrt(1.0) 
Efm=Vt-j*Ia*Xsm 
Efg=abs(Efm) 
P_emax=3*Vt*Efg/Xsm 
print(P_emax,'max power(W)') 
p=24 
f=50 

#Calculations
w_sm=(120*f*2*math.pi)/(p*60) 
Tmax=P_emax/w_sm 
print(Tmax,'torque(Nm)') 

Xsg=4.55 
Efm=Vt-j*Ia*Xsg 
Efmm=abs(Efm) 
X=Xsm+Xsg 
P_emax=3*Efg*Efmm/X 
print(P_emax,'max power(W)') 
Tmax=P_emax/w_sm 
print(Tmax,'torque(Nm)') 

d=90 
Efm=Efg*complex(math.cos(math.radians(0)),math.sin(math.radians(0))) 
Efg=Efmm*complex(math.cos(math.radians(0)),math.sin(math.radians(0)))
Ia=(Efg-Efm)/(j*X) 
v=j*Ia*Xsm 
Vt=Efm+j*Ia*Xsm 

#Results
print(abs(Vt)*math.sqrt(3),'line voltage(V)') 

(2361111.1111111115, 'max power(W)')
(90187.80108540738, 'torque(Nm)')
(571722.5941289428, 'max power(W)')
(21838.194463906242, 'torque(Nm)')
(2153.0750379274127, 'line voltage(V)')

Example 8.8 Page No 150

In [7]:
import math
#initialisation of variables
#max power supplied, power angle d, corresponding field current

  
j=math.sqrt(1) 
r=100*10**6.0     #va
V=11000.0 
P=100*10**6 
Ef=1     #pu
Vth=1     #pu
Xs=1.3     #pu
Xth=.24     #pu

#Calculations
P_emax=Ef*Vth/(Xs+Xth) 
print(P_emax,'max power delivered(pu)') 

Pe=1 
Vt=1 
d=math.degrees(math.asin(Pe*Xth/(Vt*Vth)))
print(d,'power angle') 
Vt=math.exp(j*d) 
Ia=(Vt-Vth)/(j*Xth) 
Ef=Vth+j*(Xs+Xth)*Ia 
Voc=11000 
If=256 
Ff=19150 
Iff=If*Ff/Voc

#Results
print(Iff,'If(A)') 

(0.6493506493506493, 'max power delivered(pu)')
(13.88654036262899, 'power angle')
(445, 'If(A)')

Example 8.9, Page No 152

In [10]:
import math
#initialisation of variables
#to calculate the generator current and its pf

  
j=math.sqrt(1) 
X=.24 
r=400.0     #rating in MVA
rr=600.0     #rating in MVA
Pe=r/rr 
Vt=1 
Vth=1 
dl=math.degrees(math.asin(Pe*X/(Vt*Vth)))
Ia=2*math.sin(math.radians(dl/2))/X 
V=24000 

#Calculations
IaB=(rr/3.0)*10**6/(V/math.sqrt(3.0)) 
Iaa=Ia*IaB 
print(Iaa,'generating current(A)') 
phi=dl/2.0 
pf= math.cos(math.radians(phi))
print(pf,'power factor') 

Pe=1 
dl1=math.degrees(math.asin(Pe*X/(Vt*Vth)))
Ia=2*math.sin(math.radians(dl1/2.0))/X 
Iaa=Ia*IaB 
print(Iaa,'generating current(A)') 
phi=dl1/2.0 
pf= math.cos(math.radians(phi))
print(pf,'power factor') 
Ef=Vt+j*Ia*(complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi))))*X 
Eff=abs(Ef)*V 
dl2=math.degrees(math.atan(Ef.imag/Ef.real))

Xth=.24 
Pe=abs(Ef)*Vth*math.sin(math.radians(dl1+dl2))/(X+Xth) 

#Results
print(Pe,'Pe(pu)') 

(9653.646665937797, 'generating current(A)')
(0.9967740502090344, 'power factor')
(14540.391150848647, 'generating current(A)')
(0.9926663306370695, 'power factor')
(0.560889816748067, 'Pe(pu)')

Example 8.10 Page No 163

In [11]:
import math
#initialisation of variables
#to calculate armature resistance, sync reactance, full load stray load loss, Rac/Rdc,various categories of losses at full load,full load eff

  
r=60*10**3.0 
Psc=3950.0 
Isc=108.0 

#Calculations
Raeff=Psc/(3*Isc**2) 
print(Raeff,'effective armature resistance(ohm)') 
V=400.0 
Ifoc=2.85 
Ifsc=1.21 
I_SC=Isc*Ifoc/Ifsc 
Zs=(V/math.sqrt(3))/I_SC 
Xs=math.sqrt(Zs**2-Raeff**2) 
print(Xs,'sync reactance(ohm)') 

t1=25 
t2=75 
Rdc=0.075 
Radc=Rdc*((273+t2)/(273+t1)) 
Iarated=r/(math.sqrt(3.0)*V) 
Pscc=Psc*(Iarated/Isc)**2 
P=3*Iarated**2*Radc 
print(P,'armature loss(W)') 
loss=Pscc-P 
print(loss,'loss(W)') 

a=Raeff/Radc 
print(a,'Rac/Rdc') 

Pwf=900.0 
print(Pwf,'windage and friction loss(W)') 
tloss=2440 
closs=tloss-Pwf 
print(closs,'core loss(W)') 
If=3.1 
Rf=110 
Pcu=If**2*Rf 
print(Pcu,'field cu loss(W)') 
print(loss,'stray load loss(W)') 
b=loss+Pcu+closs+Pwf+P 
print(b,'total loss(W)') 

pf=0.8 
op=r*pf 
ip=op+b 
eff=op/ip 

#Results
print(eff,'efficiency') 

(0.11288294467306813, 'effective armature resistance(ohm)')
(0.9008089329407498, 'sync reactance(ohm)')
(1687.5, 'armature loss(W)')
(852.3662551440325, 'loss(W)')
(1.5051059289742417, 'Rac/Rdc')
(900.0, 'windage and friction loss(W)')
(1540.0, 'core loss(W)')
(1057.1000000000001, 'field cu loss(W)')
(852.3662551440325, 'stray load loss(W)')
(6036.966255144032, 'total loss(W)')
(0.8882808071304457, 'efficiency')

Example 8.11, Page No 164

In [12]:
import math
#initialisation of variables
#to calculate net power op,eff,line current and pf

  
j=math.sqrt(1) 
Zs=(1.0/3)*(.3+j*6) 
phi=math.degrees(math.atan(Zs.imag/Zs.real))
Vt=400.0/math.sqrt(3.0) 
Ef=600.0/math.sqrt(3.0) 
a=math.sqrt(Vt**2+Ef**2-2*Vt*Ef*math.cos(math.radians(phi))) 
Ia=a/abs(Zs) 

#Calculations
print(Ia,'line current(A)') 
B=math.degrees(math.acos((Vt**2+a**2-Ef**2)/(2*Vt*a)))
phi=90-(90-math.degrees(math.atan(Zs.imag/Zs.real)))-B 
print(math.cos(math.radians(phi)),'pf') 
Pein=Vt*Ia*math.cos(math.radians(phi)) 
Ra=.1 
b=Ia**2*Ra 
loss=2400 
Pmout=Pein-loss/3.0-b 

#Results
print(Pmout,'net power op(W)') 
eff=Pmout/Pein 
print(eff*100,'efficiency(%)') 

(54.98573992282153, 'line current(A)')
(-0.9999999999999998, 'pf')
(-13800.755857898721, 'net power op(W)')
(108.68095238095239, 'efficiency(%)')

Example 8.12 Page No 165

In [15]:
import math
#initialisation of variables
#to find pf

  
j=math.sqrt(1) 
Zs=.8+j*5 
Vt=3300.0/math.sqrt(3) 
Pein=800*10**3.0/3     #per ph
pf=.8 
Qe=-Pein*math.tan(math.radians(math.degrees(math.acos(pf))))
#a=Ef*math.cos(math.radians(dl-a))
#b=Ef=math.cos(math.radians(dl-a))

#Calculations
a=((abs(Zs)/Vt)*(Pein-Zs.real*(Vt/abs(Zs))**2)) 
b=((abs(Zs)/Vt)*(-Qe+(Zs.imag)*(Vt/abs(Zs))**2)) 

Ef=math.sqrt(a**2+b**2) 

Pein=(1200.0/3)*1000 
a=math.degrees(math.asin((abs(Zs)/(Vt*Ef))*(Pein-pf*(Vt/abs(Zs))**2)))
Qe=(Zs.imag)*(Vt/abs(Zs))**2-Ef*Vt*math.cos(math.radians(a))/abs(Zs) 
pf=math.cos(math.radians(math.degrees(math.atan(Qe/Pein))))

#Results
print(pf,'pf') d

(0.8329179992811746, 'pf')

Example 8.13 Page No 165

In [3]:
import math
#to determine excitation emf, torque angle,stator current, pf, max power, kVAR delivered

  
j=math.sqrt(1) 
P=10000.0 
V=400.0 
Ia=P/(math.sqrt(3)*V) 
pf=.8 
phi=math.degrees(math.acos(pf))
Iaa=Ia*complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi))) 
Vt=V/math.sqrt(3.0) 
X=16 
Ef=Vt+j*X*Iaa 
print(abs(Ef),'excitation emf(V)') 
dl=math.degrees(math.atan(Ef.imag/Ef.real))
print(dl,'torque angle') 

#Calculations
Pe=P*pf 
Eff=abs(Ef)*1.2 
dl=(Pe/3)*X/(Eff*Vt) 
ta=math.degrees(math.asin(dl))
print(ta,'torque angle') 
Ia=(Eff*complex(math.cos(math.radians(ta)),math.sin(math.radians(ta)))-Vt)/(j*X) 
print(abs(Ia),'stator current(A)') 
print(math.cos(math.radians(-math.degrees(math.atan(Ia.imag/Ia.real)))),'pf') 

Ef=413 
Pemax=Ef*Vt/X 
Ia=(Ef*complex(math.cos(math.radians(90)),math.sin(math.radians(90)))-Vt)/(j*X) 
print(abs(Ia),'stator current(A)') 
print(math.cos(math.radians(-math.degrees(math.atan(Ia.imag/Ia.real)))),'pf') 

Qe=((Ia.imag)/(Ia.real))*Pe 

#Results
print(Qe,'kVar delivered') 

(438.17804600413285, 'excitation emf(V)')
(-18.434948822922003, 'torque angle')
(20.570777448577868, 'torque angle')
(20.003478706674613, 'stator current(A)')
(0.8165675681224028, 'pf')
(29.57394950937959, 'stator current(A)')
(0.48805644728523245, 'pf')
(-14306.739670518926, 'kVar delivered')

Example 8.14 Page No 172

In [6]:
import math
#initialisation of variables
#to calculate armature current, pf ,power angle, power , shaft torques,kVar

j=math.sqrt(1) 
P=8000.0 
Prot=500.0 
Pmg=P+Prot 
Pein=Pmg 
Ef=750.0/math.sqrt(3) 
Vt=231 
Xs=16.0 
dl=math.degrees(math.asin(Xs*(Pein/3)/(Ef*Vt)))
Eff=Ef*complex(math.cos(math.radians(-dl)),math.sin(math.radians(-dl))) 
Ia=(Vt-Eff)/(j*Xs) 

#Calculations
print(abs(Ia),'armature current(A)') 
print(math.cos(math.radians(-math.degrees(math.atan(Ia.imag/Ia.real)))),'pf') 
f=50 
p=4 
n_s=120*f/p 
w_s=2*math.pi*n_s/60 
T=Pein/w_s 
print(T,'torque developed(Nm)') 
T_s=P/w_s 
print(T_s,'shaft torques(Nm)') 

Ef=600/math.sqrt(3) 
Ia=(Vt-Ef)/(j*Xs) 
rr=3*Vt*Ia/1000 
print(rr,'kVar rating') 
c=(abs(Ia)/Vt)/(2*math.pi*f) 
print(-c,'capicator rating(F)') 

Ef=300/math.sqrt(3) 
Ia=(Vt-Ef)/(j*Xs) 
rr=3*Vt*Ia/1000 
print(-rr,'kVar rating') 
L=(Vt/abs(rr))/(2*math.pi*f) 
print(L,'inductor rating(H)') 

Ia=j*2000/Vt 
Ef=Vt-j*Ia*Xs 

#Results
print(abs(Ef)*math.sqrt(3),'excitation(V)') 

(15.629324184839682, 'armature current(A)')
(0.6197800073964136, 'pf')
(54.11268065124441, 'torque developed(Nm)')
(50.929581789406505, 'shaft torques(Nm)')
(-4.998702620565402, 'kVar rating')
(-9.939446800839497e-05, 'capicator rating(F)')
(-2.503242439717299, 'kVar rating')
(0.2937373645549075, 'inductor rating(H)')
(160.16596233973502, 'excitation(V)')

Example 8.15, Page No 176

In [9]:
import math
#initialisation of variables
#find the excitation emf,mech power developed,pf

j=math.sqrt(1) 
V=6600.0 
Vt=V/math.sqrt(3) 
r=4*10.0**6 
Ia=r/(math.sqrt(3)*V) 
Xs=4.8 
#Vt**2+Ef**2-2*Vt*Efcosd(dl)=(Ia*Xs)**2
#after solving
#Ef**2-7.16*Ef+11.69=0 
def quad(a,b,c):
    d=math.sqrt(b**2-4*a*c) 
    x1=(-b+d)/(2*a) 
    x2=(-b-d)/(2*a) 
    return x1,x2

Ef=[0,0]

#Calculations
Ef=quad(1,-7.16,11.69) 
dl=20.0
print(Ef[0],'excitation(kV)') 
Pm=3*3.81*Ef[0]*math.sin(math.radians(dl))/Xs 
print(Pm,'power developed(MW)') 
pf1=Pm*10**6/(math.sqrt(3)*V*Ia) 
print(pf1,'pf1') 

print(Ef[1],'excitation(kV)') 
Pm=3*3.81*Ef[1]*math.sin(math.radians(dl))/Xs 
print(Pm,'power developed(MW)') 
pf2=Pm*10**6/(math.sqrt(3)*V*Ia) 

#Results
print(pf2,'pf2') 

(4.641319932913728, 'excitation(kV)')
(3.780055563783382, 'power developed(MW)')
(0.9450138909458456, 'pf1')
(2.518680067086272, 'excitation(kV)')
(2.0513023748834374, 'power developed(MW)')
(0.5128255937208593, 'pf2')

Example 8.16, Page No 186

In [10]:
import math
#initialisation of variables
#to find power angle,field current
j=math.sqrt(1.0) 
V=400 
Vt=V/math.sqrt(3.0) 
pf=1.0 
Ia=50.0 
Xs=1.3 

#Calculations
Ef=Vt-j*Ia*Xs 
print(-math.degrees(math.atan(Ef.imag/Ef.real)),'power angle') 

Pm=Vt*Ia*pf 
pff=.8 
Ia=Pm/(Vt*pff) 
ang=math.degrees(math.acos(pff))
Eff=math.sqrt((Vt*math.cos(math.radians(ang)))**2+(Vt*math.cos(math.radians(ang))+Ia*Xs)**2) 
If=.9 
Iff=If*Eff/abs(Ef)

#Results
print(Iff,'field current(A)') 

(-0.0, 'power angle')
(1.7565442792743275, 'field current(A)')

Example 8.17, Page No 187

In [1]:
import math
#initialisation of variables
#to calculate motor eff,excitation emf and power angle, max power op,corresponding net op

  
j=math.sqrt(1.0) 
Sop=40*1000.0 
Vt=600.0 
Ra=0.8 
Xs=8 

Pst=2000.0 
Pmnet=30*1000.0 
Pm_dev=Pst+Pmnet 
Ia=Sop/(math.sqrt(3)*Vt) 
Poh=3*Ia**2*Ra 
Pin=Pm_dev+Poh 
eff=(1-(Poh+Pst)/Pin)*100 
print(eff,'motor eff(%)') 

#Calculations
cos_phi=Pin/(math.sqrt(3.0)*Vt*Ia) 
phi=math.degrees(math.acos(cos_phi))
Ia=Ia*(math.cos(math.radians(phi))+j*math.sin(math.radians(phi))) 
Vt=Vt/math.sqrt(3.0) 
Za=Ra+Xs*j 
Ef=Vt-Ia*Za 
Ef_line=Ef*math.sqrt(3.0) 
print(Ef_line,'excitation emf(V)') 
delta=math.degrees(math.atan((Ef.imag)/(Ef.real)))
print(delta,'power angle(deg)') 
IaRa=abs(Ia)*Ra 
IaXs=abs(Ia)*Xs 
AD=Vt*math.cos(math.radians(phi))-IaRa
CD=Vt*math.cos(math.radians(phi))+abs(Ia)*Xs 
Ef_mag=math.sqrt((abs(AD))**2+(abs(CD))**2) 

Pm_out_gross=-((abs(Ef_mag))**2*Ra/(abs(Za))**2)+(Vt*abs(Ef_mag)/abs(Za))

#Results
print(Pm_out_gross,'max power op(W)') 
power_angle=math.degrees(math.atan((Za.imag)/(Za.real))) 
print(power_angle,'power angle(deg)') 

(84.375, 'motor eff(%)')
(-190.24688522544741, 'excitation emf(V)')
(-0.0, 'power angle(deg)')
(24191.612053989564, 'max power op(W)')
(0.0, 'power angle(deg)')

Example 8.18, Page No 197

In [2]:
import math
#initialisation of variables
#find the change in the poweer angle 

Pe=4000.0 
V=400 
pf=.8 

#Calculations
dl=math.degrees(math.acos(pf))
Ia=Pe/(math.sqrt(3.0)*V*pf) 
Vt=V/math.sqrt(3.0) 
Xs=25 
Ef=Vt+j*Ia*complex(math.cos(math.radians(-dl)),math.sin(math.radians(-dl)))*Xs 
a=math.degrees(math.atan((Ef.imag)/(Ef.real)))

dl=math.degrees(math.asin((Pe/3)*Xs/(Vt*abs(Ef)))) 
ang=dl+a 

#Results
print(ang,'change in power angle(deg)') 

(5.596898962201344, 'change in power angle(deg)')

Example 8.19, Page No 198

In [3]:
import math
#initialisation of variables
#to find no of poles,MVA rating, prime mover rating and op torque
 
f=50.0 
n_s=100.0 
P=120*f/n_s 
print(P,'no of poles') 
r=110     #MVA rating
pf=.8 

#Calculations
rr=r/pf 
print(rr,'MVA rating') 
eff=.971 
rt=r/eff 
print(rt,'prime mover rating(MW)') 
T_PM=rt*1000*60/(2*math.pi*n_s) 

#Results
print(T_PM,'op torque(Nm)') 

(60.0, 'no of poles')
(137.5, 'MVA rating')
(113.28527291452112, 'prime mover rating(MW)')
(10817.946698316264, 'op torque(Nm)')

Example 8.20, Page No 198

In [19]:
import math
#initialisation of variables
# To calculate sec. line voltage, line current and output va

print('(a)Y/D conn') 
V_LY=6600 
V_PY=V_LY/math.sqrt(3) 
a=12 
V_PD=V_PY/a 
V_LD=V_PD     
print(V_LD,'sec line voltage(V)') 

#Calculations
I_PY=10 
I_PD=I_PY*a 
I_LD=I_PD*math.sqrt(3)     
print(I_LD,'sec. line current(A)') 
r=math.sqrt(3)*V_LD*I_LD     
print(r,'output rating(va)') 

print('(b)D/Y conn') 
I_LD=10 
I_PD=I_LD/math.sqrt(3) 
I_LY=I_PD*a         
print(I_LY,'sec. line current(A)') 
V_PD=6600 
V_PY=V_PD/a 
V_LY=V_PY*math.sqrt(3)     
print(V_LY,'sec line voltage(V)') 
r=math.sqrt(3)*V_LY*I_LY    

#Results
print(r,'output rating(va)') 

(a)Y/D conn
(317.5426480542942, 'sec line voltage(V)')
(207.84609690826525, 'sec. line current(A)')
(114315.3532995459, 'output rating(va)')
(b)D/Y conn
(69.2820323027551, 'sec. line current(A)')
(952.6279441628825, 'sec line voltage(V)')
(114315.3532995459, 'output rating(va)')

Example 8.23, Page No 231

In [11]:
import math
#initialisation of variables
#to calculate pu adjusted sync reactance, feild reactance, reactive power op, rotor power angle

  
j=math.sqrt(1.0) 
r=10*10**6 
V_SC=13.8*10**3 
Ia=r/(math.sqrt(3.0)*V_SC) 
If=226.0 


#Calculations
Iff=842.0 
I_SC=Ia*Iff/If 
Xsadj=(V_SC/math.sqrt(3))/I_SC 

va_b=10*10**6 
v_b=13800 
Xspu=Xsadj*va_b/v_b**2 
print(Xspu,'Xs(pu)') 
Ra=.75 
Zs=Ra+j*Xsadj 
a=90-math.degrees(math.atan((Zs.imag)/(Zs.real))) 

pf=.9 
phi=math.degrees(math.acos(pf)) 
Pe=8.75*10**6 
Qe=Pe*math.tan(math.radians(phi)) 
Vt=V_SC/math.sqrt(3) 
Ia=(Pe/3.0)/(Vt*pf) 
Ef=Vt+abs(Ia)*abs(Zs)*complex(math.cos(math.radians(90-a-phi)),math.sin(math.radians(90-a-phi))) 
Ef=abs(Ef)*math.sqrt(3) 
If=Iff*Ef/V_SC 
print(If,'field current(A)') 
loss=3*abs(Ia)**2*Ra 
Pmin=Pe+loss 
print(Pmin,'reactive power op(W)') 

If=842 
Voc=7968 
Pmin=Pmin/3 
dl=math.degrees(math.asin((Pmin-(Zs.real)*(Voc/abs(Zs))**2)/((Voc**2/abs(Zs)))))+a 

#Results
print(dl,'power angle') 
Q=-(Voc/abs(Zs))**2*(Zs.imag)+Voc**2*math.cos(math.radians(dl+a))/abs(Zs) 
print(Q,'reactive power op(VAR)') 

(0.2684085510688836, 'Xs(pu)')
(1074.3932057155528, 'field current(A)')
(9122249.546858348, 'reactive power op(W)')
(44.00614893481687, 'power angle')
(-7524957.4047774, 'reactive power op(VAR)')

Example 8.25, Page No 231

In [1]:
import math
#initialisation of variables
#to calculate the excitation emf,power angle

  
Vt=1.0
Ia=1.0 
pf=.8 
phi=math.degrees(math.acos(pf)) 
Iaa=Ia*complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi))) 
Xq=.5 

#Calculations
j=math.sqrt(1) 
Ef=Vt+j*Iaa*Xq 

dl=17.1 
w=phi+dl 
Id=Ia*math.sin(math.radians(w))
Xd=.8 
CD=Id*(Xd-Xq) 
Eff=abs(Ef)+CD 
Ef=Vt+j*Iaa*Xd 

#Results
print(abs(Ef),'excitation emf(V)') 
print(math.degrees(math.atan((Ef.imag)/(Ef.real))),'power angle') 

(1.7088007490635064, 'excitation emf(V)')
(-16.313852426260553, 'power angle')

Example 8.26, Page No 231

In [3]:
import math
#initialisation of variables
#calculate excitation emf

  
V=3300.0 
Vt=V/math.sqrt(3.0) 
pf=1 
phi=math.degrees(math.acos(pf)) 
P=1500.0*1000 

#Calculations
Ia=P/(math.sqrt(3.0)*V*pf) 
Xq=2.88 
Xd=4.01 
w=math.degrees(math.atan((Vt*0-Ia*Xq)/Vt))
dl=phi-w 
Id=Ia*math.sin(math.radians(w))
Iq=Ia*math.cos(math.radians(w)) 
Ef=Vt*math.cos(math.radians(dl))-Id*Xd 

#Results
print(Ef*math.sqrt(3.0),'excitation emf(line)(V)') 

(3739.5700468573696, 'excitation emf(line)(V)')

Example 8.27, Page No 231

In [9]:
import math
#initialisation of variables
#to calculate generator terminal voltage,excitation emf,power angle
 
Xd=1.48 
Xq=1.24 
Xe=.1 
Xdt=Xd+Xe 
Xqt=Xq+Xe 

MVA=1 
Vb=1 
pf=.9 

#Calculations
phi=math.degrees(math.acos(pf))
#(Vt*math.cos(math.radians(phi)))**2+(Vt*math.sin(math.radians(phi))+Ia*Xe)**2=Vb**2 
#after solving
#Vt**2-.0870*Vt-.99=0 
def	quad(a,b,c):
    d=math.sqrt(b**2-4*a*c) 
    x1=(-b+d)/(2*a) 
    x2=(-b-d)/(2*a) 
    if x1 < Vb :
        x=x2
    else :
        x=x1 
	return x
Vt=quad(1,-.0870,-.99) 
print(Vt,'terminal voltage(V)') 
#after solving
phi=20 

j=math.sqrt(1) 
Ia=1 
Iaa=Ia*complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi))) 
Ef=Vb+j*Iaa*Xqt 
Eff=abs(Ef) 
dl=math.degrees(math.atan((Ef.imag)/(Ef.real)))
print(dl,'power angle') 
w=dl+phi 
Id=Ia*math.sin(math.radians(w)) 
Ef=Ef+Id*(Xdt-Xqt) 

#Results
print(abs(Ef),'excitation emf(V)') 

(1.0394378745684894, 'terminal voltage(V)')
(-11.46760596259884, 'power angle')
(2.34011465088481, 'excitation emf(V)')

Example 8.28, Page No 231

In [11]:
import math
#initialisation of variables
#to find max pu power, pu armature current, pu reactive power

  
Vt=1 
Xd=1.02 
Xq=.68 
Pmmax=Vt**2*(Xd-Xq)/(2*Xd*Xq) 
print(Pmmax,'max pu power') 
dl=.5*math.degrees(math.asin(Pmmax/(Vt**2*(Xd-Xq)/(2*Xd*Xq)))) 

#Calculations
Id=Vt*math.cos(math.radians(dl))/Xd 
Iq=Vt*math.cos(math.radians(dl))/Xq 
Ia=math.sqrt(Id**2+Iq**2) 
print(Ia,'armature current(pu)') 

Qe=Id*Vt*math.cos(math.radians(dl))+Iq*Vt*math.sin(math.radians(dl)) 
print(Qe,'reactive power(pu)') 

pf=math.cos(math.radians(math.degrees(math.atan(Qe/Pmmax))))

#Results
print(pf,'pf') 

(0.2450980392156862, 'max pu power')
(1.249759684704114, 'armature current(pu)')
(1.2254901960784315, 'reactive power(pu)')
(0.196116135138184, 'pf')

Example 8.29, Page No 231

In [1]:
import math
#initialisation of variables
#to calculate power angle,excitation emf,field current
j=math.sqrt(1.0) 
MVA_b=300.0 
kV_b=22.0 

Pe=250.0/MVA_b 
pf=.85 
Vt=1 

#Calculations
Ia=Pe/(pf*Vt) 
phi=math.degrees(math.acos(pf))
Iaa=Ia*complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi))) 
Xq=1.16 
Xd=1.93 
Ef=Vt+j*Iaa*Xq 
dl=math.degrees(math.atan((Ef.imag)/(Ef.real)))
print(dl,'power angle') 
w=phi+dl 
Id=abs(Iaa)*math.sin(math.radians(w)) 
Ef=abs(Ef)+Id*(Xd-Xq) 
print(Ef*kV_b,'excitation emf(V)') 

If=338.0 
If=If*Ef/1 

#Results
print(If,'field current(A)') 

(-16.941789546757967, 'power angle')
(49.48501576455793, 'excitation emf(V)')
(760.2697876554809, 'field current(A)')

Example 8.30, Page No 231

In [2]:
import math
#initialisation of variables
#to find max andmin pu field excitation

  
Xd=.71 
Xq=.58 
Xe=.08 
Xdt=Xd+Xe 
Xqt=Xq+Xe 

#Calculations
Pe=0 
Vt=1 
dl=0 
phi=90 
Ia=1 
Iq=0 
Id=Ia 

Ef=Vt+Id*Xdt 
Ifmax=Ef 
print(Ifmax,'max field excitation(A)') 


Ef=Vt-Id*Xdt 
Ifmin=Ef 

#Results
print(Ifmin,'min field excitation(A)') 

(1.79, 'max field excitation(A)')
(0.21000000000000008, 'min field excitation(A)')

Example 8.31, Page No 231

In [4]:
import math
#initialisation of variables
#to calculate synchronising power and torque coeff/deg mech shift

  
V=11000.0
Vt=V/math.sqrt(3) 
P=6*10**6.0 

#Calculations
Ia=P/(math.sqrt(3)*V) 
ohm_b=Vt/Ia 
Xs=.5 
Xss=Xs*ohm_b 

f=50.0 
P=8.0 
n_s=(120*f/P)*(2*math.pi/60) 

Ef=Vt 
dl=0 
Psyn=(math.pi/15)*(Ef*Vt/Xss)*math.cos(math.radians(dl))
print(Psyn,'synchronising power(W)') 
Tsyn=Psyn/n_s 
print(Tsyn,'torque coeff(Nm)') 

pf=.8 
phi=math.degrees(math.acos(pf)) 
Ef=Vt+j*Ia*Xss*complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi))) 
dl=math.degrees(math.atan((Ef.imag)/(Ef.real)))
Psyn=(math.pi/15)*(abs(Ef)*Vt/Xss)*math.cos(math.radians(dl)) 

#Results
print(Psyn,'synchronising power(W)') 
Tsyn=Psyn/n_s 
print(Tsyn,'torque coeff(Nm)') 

(837758.0409572781, 'synchronising power(W)')
(10666.666666666666, 'torque coeff(Nm)')
(1172861.257340189, 'synchronising power(W)')
(14933.333333333328, 'torque coeff(Nm)')

Example 8.32, Page No 231

In [6]:
import math
#to calculate syncronising power/elec deg,pu sync torque/mech deg
 
j=math.sqrt(1.0) 
Xd=.8 
Xq=.5 
Vt=1 
pf=.8 
phi=math.degrees(math.acos(pf))
Ia=1*complex(math.cos(math.radians(phi)),math.sin(math.radians(phi))) 

Ef=Vt-j*Ia*Xq 
Eff=abs(Ef) 

#Calculations
dl=math.degrees(math.atan((Ef.imag)/(Ef.real))) 
w=-dl+phi 
Id=abs(Ia)*math.sin(math.radians(w))
Ef=Eff+Id*(Xd-Xq) 

Psyn=abs(Ef)*Vt*math.cos(math.radians(dl))/Xd+Vt**2*((Xd-Xq)/(Xd*Xq))*math.cos(math.radians(2*dl))
print(Psyn*(math.pi/180),'syncronising power(pu)/elec deg') 
f=50 
P=12 
n_s=(120*f/P)*(2*math.pi/60) 
Tsyn=Psyn/n_s 

#Results
print(Tsyn,'pu sync torque/mech deg') 

(0.02617993877991495, 'syncronising power(pu)/elec deg')
(0.028647889756541166, 'pu sync torque/mech deg')

Example 8.33, Page No 231

In [7]:
import math
#to calculate sync current, power and torque

  
j=math.sqrt(1.0) 
P=12000.0 
V=400.0 
pf=.8 
Ia=P/(math.sqrt(3)*V*pf) 
phi=math.degrees(math.acos(pf))
Vt=V/math.sqrt(3) 
Xs=2.5 

#Calculations
Ef=Vt-j*Ia*complex(math.cos(math.radians(phi)),math.sin(math.radians(phi)))*Xs 
tandl=4 
Es=2*abs(Ef)*math.cos(math.radians(tandl/2)) 
Is=Es/Xs 
print(Is,'sync current(A)') 
dl=math.degrees(math.atan((Ef.imag)/(Ef.real)))
Ps=3*Vt*Is*math.cos(dl+tandl/2)
print(Ps,'power(W)') 
n_s=25*math.pi 
T_s=Ps/n_s 

#Results
print(T_s,'torque(Nm)') 

(152.2500120412367, 'sync current(A)')
(3657.484067729796, 'power(W)')
(46.568533492723965, 'torque(Nm)')

Example 8.34, Page No 231

In [8]:
import math
#initialisation of variables
#to calculate value of syncpower

  
V=6600.0
E=V/math.sqrt(3.0) 

P=12.0 
dl=1.0*P/2 

#Calculations
r=20000.0*10**3 
I=r/(math.sqrt(3.0)*V) 
Xs=1.65 

Psy=dl*(math.pi/180.0)*E**2/Xs 

#Results
print(Psy,'sync power(W)') 

(921533.8450530063, 'sync power(W)')

Example 8.35, Page No 231

In [9]:
import math
#initialisation of variables
#to determine op current and pf

  
P1=400.0*10**3 
P2=400.0*10**3 
P3=300.0*10**3 
P4=800.0*10**3 
pf1=1 
pf2=.85 
pf3=.8 
pf4=.7 

#Calculations
phi1=math.degrees(math.acos(pf1))
phi2=math.degrees(math.acos(pf2)) 
phi3=math.degrees(math.acos(pf3)) 
phi4=math.degrees(math.acos(pf4))
P=P1+P2+P3+P4 
Q1=P1*math.tan(math.radians(phi1))
Q2=P2*math.tan(math.radians(phi2)) 
Q3=P3*math.tan(math.radians(phi3))
Q4=P4*math.tan(math.radians(phi4)) 
Q=Q1+Q2+Q3+Q4 

I=100 
pf=.9 
V=6600.0 
P_A=math.sqrt(3)*V*I*pf 
P_B=P-P_A 
Q_A=P_A*math.tan(math.radians(math.degrees(math.acos(pf))) )
Q_B=Q-Q_A 
phi=math.degrees(math.acos(Q_B/P_B))
pf=math.cos(math.radians(phi))
print(pf,'pf') 
I_B=P_B/(math.sqrt(3.0)*pf*V) 

#Results
print(I_B,'op current(A)') 

(0.9077210377902825, 'pf')
(83.9540921749662, 'op current(A)')

Example 8.36, Page No 231

In [10]:
import math
#initialisation of variables
#to find the pf and current supplied by the m/c

P=50000.0
pf=.8 
phi=math.degrees(math.acos(pf))
Q=P*math.cos(math.radians(phi)) 
P1=P/2 
pf1=.9 

#Calculations
phi1=math.degrees(math.acos(pf1))
Q1=P1*math.cos(math.radians(phi1)) 
P2=P/2 
Q2=Q-Q1 
phi2=math.degrees(math.atan(Q2/P2))
pf=math.cos(math.radians(phi2)) 
print(pf,'pf') 
V_L=400.0
I2=P2/(math.sqrt(3)*V_L*pf) 

#Results
print(I2,'current supplied by m/c(A)') 

(0.8192319205190405, 'pf')
(44.04661356638744, 'current supplied by m/c(A)')

Example 8.37, Page No 231

In [12]:
#to find initial current,current at the end of 2 cycles and at the end of 10s

  
Ef=1.0 
Xd2=.2 
I2=Ef/Xd2 
r=100*10**6 
V=22000.0 

#Calculations
I_b=r/(math.sqrt(3)*V) 
I2=I2*I_b 
print(I2,'initial current(A)') 

Xd1=.3 
I1=Ef/Xd1 
Xd=1 
I=Ef/Xd 

tau_dw=0.03 
tau_f=1 

def I_sc(t):
    a=(I2-I1)*math.exp(-t/tau_dw)+(I1-I)*math.exp(-t/tau_f)+1 
    return a
#2 cycles=0.04s

#Results
print(I_sc(.2867)*I_b,'current at the end of 2 cycles(A)') 
print(I_sc(10)*I_b,'current at the end of 10s(A)') 

(13121.597027036949, 'initial current(A)')
(9656.315026038814, 'current at the end of 2 cycles(A)')
(2624.5974078796426, 'current at the end of 10s(A)')

Example 8.39, Page No 231

In [13]:
import math
#initialisation of variables
#to calculate sync reactance,voltage regulation,torque angle, ele power developed, voltage and kva rating

  
r=1000.0*10**3 
V=6600.0 
Ia=r/(math.sqrt(3.0)*V) 
pf=.75 

#Calculations
phi=-math.degrees(math.acos(pf))
Vt=V/math.sqrt(3.0) 
Ef=11400.0/math.sqrt(3) 
#Ef*complex(cosd(dl),sind(dl))=Vt+j*Xs*Ia*complex(cosd(phi),sind(phi))
#after solving
#6.58*cosd(dl)=3.81+.058*Xs 
#6.58*sind(dl)=.0656*Xs 
#so after solving 
#cosd(dl-phi)=.434 
dl=math.degrees(math.acos(0.434))+phi 

Xs=Ef*math.sin(math.radians(dl))/65.6 

#Results
print(Xs,'sync reactance(ohm)') 
vr=Ef*math.sqrt(3.0)/V-1 
print(vr,'voltage regulation(%)') 
print(dl,'torque angle(deg)') 
P=3*Ef*Ia*math.cos(math.radians(dl-phi)) 
print(P,'ele power developed(W)') 

volr=V/math.sqrt(3) 
print(volr,'voltage rating(V)') 
ir=Ia*math.sqrt(3) 
print(ir,'current rating(A)') 
r=math.sqrt(3)*volr*ir 
print(r,'VA rating') 

(38.99116776362744, 'sync reactance(ohm)')
(0.7272727272727273, 'voltage regulation(%)')
(22.86869850821798, 'torque angle(deg)')
(749636.3636363635, 'ele power developed(W)')
(3810.5117766515305, 'voltage rating(V)')
(151.5151515151515, 'current rating(A)')
(999999.9999999999, 'VA rating')

Example 8.40, Page No 231

In [15]:
import math
#initialisation of variables
#to determine m/c and pf

  
j=math.sqrt(1.0) 
P=230.0*10**6 
V=22000.0 
pf=1.0 

#Calculations
Ia=P/(math.sqrt(3)*V*pf) 
Vt=V/math.sqrt(3) 
Xs=1.2 
Ef=Vt+j*Xs*Ia 
#if Ef is inc by 30%
Ef=1.3*abs(Ef) 

dl=math.degrees(math.asin((P/3.0)*Xs/(Ef*Vt)))
Ia=((Ef*complex(math.cos(math.radians(dl)),math.sin(math.radians(dl))))-Vt)/(j*Xs) 
print(abs(Ia),'m/c current(A)') 
print(math.cos(math.radians(math.degrees(math.atan((Ia.imag)/(Ia.real))))),'pf') 
P=275*10**6 
dl=math.degrees(math.asin((P/3.0)*Xs/(Ef*Vt)))
Ia=((Ef*complex(math.cos(math.radians(dl)),math.sin(math.radians(dl))))-Vt)/(j*Xs) 

#Results
print(abs(Ia),'m/c current(A)') 
print(math.cos(math.radians(math.degrees(math.atan((Ia.imag)/(Ia.real))))),'pf') 

(11819.373430797657, 'm/c current(A)')
(0.8597700086643913, 'pf')
(12155.509739365927, 'm/c current(A)')
(0.8046772266804496, 'pf')

Example 8.41, Page No 231

In [18]:
#to calculate excitation emf,torque angle, eff, shaft op
import math
#initialisation of variables
  
j=math.sqrt(1.0) 
Va=.8 
Xa=5.5 
Xs=Va+j*Xa 
V=3300.0 
Ia=160.0 
pf=.8 
loss=30000.0

#Calculations
phi=math.degrees(math.acos(pf))
Ef=V/math.sqrt(3.0)-Xs*Ia*complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi)))
print(abs(Ef),'excitation emf(V)') 
dl=math.degrees(math.atan((Ef.imag)/(Ef.real)))
print(dl,'torque angle(deg)') 
P_mech=3*abs(Ef)*Ia*math.cos(math.radians(-phi-dl)) 
op_sft=P_mech-loss 
print(op_sft,'shaft op(W)') 
Pip=math.sqrt(3.0)*V*Ia*pf 
eff=op_sft/Pip

#Results
print(eff*100,'efficiency(%)') 

(1254.2995269504831, 'excitation emf(V)')
(28.82797497778111, 'torque angle(deg)')
(217778.26111709396, 'shaft op(W)')
(29.76665191278476, 'efficiency(%)')

Example 8.42, Page No 231

In [4]:
#to caculate generator current,pf, real power,ecitation emf
import math
#initialisation of variables

  
r=500.0*10**6 
V=22000 
Ia=r/(math.sqrt(3.0)*V) 
print(Ia,'generator current(A)') 
Vt=V/math.sqrt(3.0) 
Zb=Vt/Ia 
MVA_b=500.0
MW_b=500.0 
Xsg=1.57 
Xb=.4 
Xb=Xb/Zb 
rr=250.0 
rr=rr/MVA_b 
Vb=1 
Vt=1 
Ia=.5 

#Calculations
phi=math.degrees(math.asin(Xb*Ia/2))
pf=math.cos(math.radians(phi))
print(pf,'pf') 
Pe=rr*pf 
print(Pe,'real power(pu)') 
Eg=complex(Vt,Xsg*rr**complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi))))
Egg=abs(Eg)*V 
print(Egg,'excitation emf(V)') 


rr=500.0 
rr=rr/MVA_b 
Vb=1 
Vt=1 
Ia=1 
phi=math.degrees(math.asin(Xb*Ia/2))
pf=math.cos(math.radians(phi))
print(pf,'pf') 
Pe=rr*pf 
print(Pe,'real power(pu)') 
Eg=complex(Vt,Xsg*rr**complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi))))
Egg=abs(Eg)*V 


#Results
print(Egg,'excitation emf(V)') 

(13121.597027036949, 'generator current(A)')
(0.9946496442265089, 'pf')
(0.49732482211325446, 'real power(pu)')
(27016.768055398476, 'excitation emf(V)')
(0.9784230470709913, 'pf')
(0.9784230470709913, 'real power(pu)')
(40951.33209066587, 'excitation emf(V)')

Example 8.43, Page No 231

In [6]:
#to  ulate pf angle, torque angle,equivalent capicitor and inductor value
import math
#initialisation of variables

of1=250.0 
scr=0.52     #short ckt ratio
of2=of1/scr 
r=25.0*10**6 
V=13000.0 

#Calculations
Ia=r/(math.sqrt(3.0)*V) 
Isc=Ia*of1/of2 
Xs=V/(math.sqrt(3.0)*Isc) 
Xb=V/(math.sqrt(3.0)*Ia) 
Xsadj=Xs/Xb 

f=50.0 
If=200.0 
Ef=V*If/of1 
Vt=V/math.sqrt(3.0) 
Ia=(Vt-Ef/math.sqrt(3.0))/Xs 
dl=0 
print(dl,'torque angle(deg)') 
pf=90.0 
print(pf,'pf angle(deg)') 
L=(V/(math.sqrt(3.0)*Ia))/(2*math.pi*f) 
print(L,'inductor value(H)') 

If=300.0 
Eff=V*If/of1 
Vt=Ef/math.sqrt(3.0) 
Ia=(Eff/math.sqrt(3)-Vt)/Xs 
dl=0 
print(dl,'torque angle(deg)') 
pf=90.0 
print(pf,'pf angle(deg)') 
c=1.0/((V/(Ia))*(2.0*math.pi*f)) 

#Results
print(c,'capacitor value(F)') 

(0, 'torque angle(deg)')
(90.0, 'pf angle(deg)')
(0.2069014260194639, 'inductor value(H)')
(0, 'torque angle(deg)')
(90.0, 'pf angle(deg)')
(5.654655337659404e-05, 'capacitor value(F)')

Example 8.44, Page No 231

In [8]:
#to determine Xs(saturated),scr,Xs(unsat)and If,generator current
import math
#initialisation of variables

  
MVA_b=400.0 
kV_b=22.0 

#Calculations
Ib=MVA_b/(math.sqrt(3.0)*kV_b) 
ohm_b=kV_b/(math.sqrt(3.0)*Ib) 

If=1120.0 
Voc=kV_b/math.sqrt(3) 
Isc=13.2 
Xssat=Voc/Isc 
print(Xssat,'Xs(saturated)(ohm)') 
Xss=Xssat/ohm_b 
print(Xss,'Xs(saturated)(pu)') 
scr=1/Xss 
print(scr,'SCR') 
Isc=Ib 
Voc=24.4/math.sqrt(3) 
Xsunsat=Voc/Isc 

#Results
print(Xsunsat,'Xs(unsaturated)(ohm)') 
Xsuns=Xsunsat/ohm_b 
print(Xsuns,'Xs(unsaturated)(pu)') 
Iff=If*scr 
print(Iff,'generator current(A)') 

(0.9622504486493764, 'Xs(saturated)(ohm)')
(0.795248304668906, 'Xs(saturated)(pu)')
(1.257468886295005, 'SCR')
(1.342, 'Xs(unsaturated)(ohm)')
(1.109090909090909, 'Xs(unsaturated)(pu)')
(1408.3651526504057, 'generator current(A)')

Example 8.45, Page No 231

In [4]:
import math
#initialisation of variables
#find motor pf

  
j=math.sqrt(1.0) 
V=6600.0 
Vt=V/math.sqrt(3.0) 
pf=.8 

#Calculations
phi=math.degrees(math.acos(pf)) 
P=800000.0 
Ia=P/(math.sqrt(3)*V*pf) 
Zs=complex(2,20) 
Ef=Vt-Zs*Ia*complex(math.cos(math.radians(phi))+math.sin(math.radians(phi))) 
Pip=1200*10**3.0 
theta=math.degrees(math.atan((Zs.imag)/(Zs.real)))
dl=math.degrees(math.acos(((Ef.real)**2*math.cos(math.radians(theta))/abs(Zs)-P/3.0)/((Ef.real)*abs(Ef)/abs(Zs))))-theta 

Ia=((Ef.real)-abs(Ef)*complex(math.cos(math.radians(-dl)),math.sin(math.radians(-dl))))/Zs 
phi=math.degrees(math.atan((Ia.imag)/(Ia.real)))

#Results
print(math.cos(math.radians(phi)),'pf') 

(0.9238712092836282, 'pf')

Example 8.46, Page No 231

In [2]:
import math
#initialisation of variables
#to find exciting emf neglecting saliency and accounting saliency

  
j=math.sqrt(1.0) 
Xd=.12/3 
Xq=.075/3.0 

print('neglecting saliency') 
Xs=Xd 
V=440.0 
pf=.8 

#Calculations
phi=math.degrees(math.acos(pf))
Vt=V/math.sqrt(3.0) 
Ia=1000.0 
Ef=Vt+j*Xs*Ia*complex(math.cos(math.radians(-phi)),math.sin(math.radians(-phi))) 
print(abs(Ef)*math.sqrt(3),'excitation emf(line)(V)') 
print('accounting saliency') 
w=math.degrees(math.atan((Vt*math.sin(math.radians(phi))+Ia*Xq)/(Vt*math.cos(math.radians(phi)))))
dl=w-phi 
Ef=Vt*math.cos(math.radians(dl))+Ia*math.sin(math.radians(dl))*Xd

#Results
print(abs(Ef)*math.sqrt(3),'excitation emf(line)(V)') 

neglecting saliency
(497.16652214438125, 'excitation emf(line)(V)')
accounting saliency
(443.9254541572264, 'excitation emf(line)(V)')

Example 8.47, Page No 231

In [6]:
import math
#initialisation of variables
#calculate excitation emf,max load motor supplies, torque angle

Xd=23.2 
Xq=14.5 
V=6600.0 
pf=.8 
phi=math.degrees(math.acos(pf))
Vt=V/math.sqrt(3.0) 
r=1500*1000.0

#Calculations
Ia=r/(math.sqrt(3.0)*V)
w=math.degrees(math.atan((Vt*math.sin(math.radians(-phi))+Ia*Xq)/(Vt*math.cos(math.radians(phi)))))
dl=-phi-w 
print(dl,'torque angle') 
Ef=Vt*math.cos(math.radians(dl))-Ia*math.sin(math.radians(w))*Xd 
print(Ef,'excitation emf(V)') 

Pe=V**2*((Xd-Xq)/(2*Xd*Xq)) 

#Results
print(Pe,'load supplied(W)') 

(-29.696320419057813, 'torque angle')
(3690.199749168095, 'excitation emf(V)')
(563275.8620689656, 'load supplied(W)')

Example 8.49, Page No 231

In [1]:
import math
#initialisation of variables
#find no load freq setting,sys freq,at no load freq of swing generator, system trip freq

  
loadtot=260.0
r=125.0 
pf=.84 

#Calculations
genfl=r*pf 
sld=75     #supply load
n=3     #no of generators
ls=loadtot-n*sld 
m=-5/genfl 
f=50 
ff=f-m*sld 
print(ff,'set freq(Hz)') 
c=f-m*ls 
print(c,'set freq(Hz) supplied from swing generator') 
nld=sld+50/4 
c=ff+m*nld 
print(c,'new system freq(Hz)') 
rld=310-n*sld 
c=f-m*rld 
print(c,'set freq(Hz) of swing generator') 
nld=310.0/n 
c=ff+m*nld 

#Results
print(c,'system trip freq(Hz)') 

(53.57142857142857, 'set freq(Hz)')
(51.666666666666664, 'set freq(Hz) supplied from swing generator')
(49.42857142857143, 'new system freq(Hz)')
(54.04761904761905, 'set freq(Hz) of swing generator')
(48.65079365079365, 'system trip freq(Hz)')