# Chapter 7: Synchronous Generators¶

## Example 7.2, Page 411¶

In [1]:
import math

#Variable declaration
P=4;#no. of poles
S=48;#no. of slots

#Calculations
S_p=S/P;#slots per pole
S_span=180/S_p;#slot span
n=S/(3*P);#no. of coils in phase group
C_span=9*S_span;#coil span
K_p=math.sin(C_span/2*math.pi/180);

#Result
print 'pitch factor =%.3f'%K_p

pitch factor =0.921


## Example 7.3, Page 414¶

In [2]:
import math

#Variable declaration
P=12;#no. of poles
S=108;#no. of slots

#Calculations
n=S/(3*P);#no. of coils in a phase group
S_p=S/P;
Y=180/S_p;#slot span (in electrical degree)
K_d=(math.sin(3*(Y/2)*math.pi/180))/(3*math.sin(Y/2*math.pi/180));

#Result
print 'distribution factor=%.2f'%K_d

distribution factor=0.96


## Example 7.5, Page 420¶

In [3]:
import math

#Variable declaration
N_m=375;#speed of motor (in rpm)
N=10;#no of turns
P=16;#no. of poles
S=144;#no. of slots
Phy=0.025;#flux (in Weber)

#Calculations&Results
S_p=S/P;#slots per pole
Y=180/S_p;#slot span
C_p=Y*7;#coil pitch
K_p=math.sin(C_p/2*math.pi/180);#pitch factor
K_d=(math.sin(3*(Y/2)*math.pi/180))/(3*math.sin(Y/2*math.pi/180));#distribution factor
K_w=K_p*K_d;#winding factor
N_e=P*3*N*K_w/2;#effective no. of turns
f=N_m*P/120;
print '(a) frequency of induced voltage (in Hertz)=%.f'%f
E_a=4.44*f*N_e*Phy;
print '(b) Rms value of Phase voltage (in Volts)=%.2f'%E_a;
E_L=E_a*math.sqrt(3);
print '(c) line voltage (in Volts)=%.f'%E_L

(a) frequency of induced voltage (in Hertz)=50
(b) Rms value of Phase voltage (in Volts)=1201.35
(c) line voltage (in Volts)=2081


## Example 7.6, Page 426¶

In [4]:
import math

#Variable declaration
V=208;#in volts
P_o=9000;

#Calculations&Results
R=complex(0.1,5.6);
V_a=int(V/math.sqrt(3));#rms value of per phase voltage
I_a=P_o/(3*V_a);#rms value of per phase current
print "(a)  For 80% lagging power factor of load"
theta=(-1)*math.acos(0.8);
I_a_L=(I_a)*complex(math.cos(theta),math.sin(theta));
E_a=V_a+I_a_L*R;#in volts
VR=((abs(E_a)-V_a)/V_a)*100;
print 'voltage regulation (%%)=%.1f'%VR
print "(b)  For Unity power factor of load"
theta=math.acos(1);
I_a_L=(I_a)*complex(math.cos(theta),math.sin(theta))
E_a=V_a+I_a_L*R;#in volts
VR=((abs(E_a)-V_a)/V_a)*100;
print 'voltage regulation (%%)=%.2f'%VR
print "(c)  For 80% leading power factor of load"
theta=math.acos(0.8);
I_a_L=(I_a)*complex(math.cos(theta),math.sin(theta));
E_a=V_a+I_a_L*R;#in volts
VR=((abs(E_a)-V_a)/V_a)*100;
print 'voltage regulation (%%)=%.2f'%VR

(a)  For 80% lagging power factor of load
voltage regulation (%)=94.8
(b)  For Unity power factor of load
voltage regulation (%)=55.02
(c)  For 80% leading power factor of load
voltage regulation (%)=-0.26


## Example 7.7, Page 432¶

In [5]:
import math

#Variable declaration
V=208;#in volts
N_m=1200;#speed of generator (in rpm)
P_r=9000;#rated power in (Volt-Amperes)

#Calculations&Results
Z_a=complex(0.3,5);#armature impedance (ohm/phase)
R_f=4.5;#feild winding resistance
P_rot=500;#rotational loss (in Watts)
I_f=5;#feild winding current
pf=0.8;#lagging
V_a=int (V/math.sqrt(3));
theta=(-1)*math.acos(pf);
I_a_o=P_r/(3*V_a);#per phase armature current (magnitude)
I_a=I_a_o*complex(math.cos(theta),math.sin(theta));
E_a=V_a+(I_a*Z_a);#per phase generated voltage
VR=((abs(E_a)-V_a)/V_a)*100;
print '(a) Voltage Regulation (%%)=%.2f'%VR
P_o=3*V_a*abs(I_a)*pf;#power output
P_cu=3*((abs(I_a))**2)*0.3;#copper loss
P_d=P_o+P_cu;#power developed
P_c=P_rot+(I_f**2)*R_f;#constant loss
P_in=P_d+P_c;#power input
Eff=(P_o/P_in)*100;
print '(b) Efficiency (%%)=%.f'%(math.ceil(Eff))
w_s=2*math.pi*N_m/60;
T=(P_d+P_rot)/w_s;
print '(c) Torque developed (in Newton-meter)=%.2f'%T

(a) Voltage Regulation (%)=85.44
(b) Efficiency (%)=86
(c) Torque developed (in Newton-meter)=65.75


## Example 7.8, Page 438¶

In [6]:
import math

#Variable declaration
V_r=2300;#rated voltage (in Volts)
P_r=500*10**3;#rated power (in Volt-Amperes)
pf=0.8;#lagging
theta=-1*(math.acos(0.8));
I_sc=150;#short circuit current (in Amperes)

#Calculations&Results
V_anL=V_r/math.sqrt(3);#open-circuit phase voltage
Z_sc=V_anL/I_sc;#(in ohms)
X_s=math.sqrt((Z_sc**2)-0.5**2);
print 'synchronous reactance per phase (in ohms)=%.2f'%X_s
I_ao=P_r/(3*V_anL);#full load current (magnitude)
I_a=I_ao*complex(math.cos(theta),math.sin(theta));
V_b=V_anL;#base value of voltage
I_b=I_ao;#base value of current
Z_b=V_b/I_b;#base value of impedance
I_apu=I_a/I_b;#per unit armature current
V_pu=V_anL/V_b;#per unit voltage
Z_spu=complex(0.5,X_s)/Z_b;#per unit impedance
E_apu=V_pu+(I_apu*Z_spu);
VR=(abs(E_apu)-1)*100;
print 'voltage regulation (%%)=%.2f'%VR

synchronous reactance per phase (in ohms)=8.84
voltage regulation (%)=66.68


## Example 7.9, Page 450¶

In [7]:
import math

#Variable declaration
V_r=13.8*10**3;#in volts
R_a=0;
X_d=1.83;#in ohms
X_q=1.21;#in ohms
P_r=70.*10**6;#in Volt-Ampere
pf=0.8;#lagging
theta=(-1)*math.acos(pf);

#Calculations&Results
V_a=V_r/(math.sqrt(3));#rms value of per phase voltage
I_ao=P_r/(3*V_a);
tan_delta=((I_ao*X_q*math.cos(theta))-(I_ao*R_a*math.sin(theta)))/(V_a+(I_ao*((R_a*math.cos(theta))-(X_q*math.sin(theta)))));
delta=math.atan(tan_delta);
alpha=delta+math.acos(pf);
I_d=I_ao*math.sin(alpha)*(complex(math.cos(delta-90),math.sin(delta-90)));
I_q=I_ao*math.cos(alpha)*(complex(math.cos(delta),math.sin(delta)));
E_a=abs(V_a+(I_q*complex(0,X_q))+(I_d*complex(0,X_d)));
VR=((E_a-V_a)/V_a)*100;
print 'voltage regulation (%%)=%.2f'%VR
P_d=3*V_a*I_ao*pf;
print 'Power developed (in Mega-Watts)=%.f'%(P_d/(10**6))

voltage regulation (%)=45.99
Power developed (in Mega-Watts)=56


## Example 7.10, Page 458¶

In [8]:
import math
import cmath

#Variable declaration
Z_s1=complex(0,5);#ohm/phase
Z_s2=complex(0,8);#ohm/phase

#Calculations&Results
Z_L=complex(4,3);#load impedance (in ohm/phase)
def phasor(theta):
return complex(math.cos(theta*math.pi/180),math.sin(theta*math.pi/180));

def angle(x,y):
return math.degrees(math.atan(y/x))

E_a1=120*phasor(10);
E_a2=120*phasor(20);
V_a=(((E_a1*Z_s2)+(E_a2*Z_s1))/((Z_L*(Z_s1+Z_s2))+(Z_s1*Z_s2)))*Z_L;
V_a_m = math.sqrt(V_a.real**2+V_a.imag**2)
print '(a) magnitude of phase voltage (in Volts)=%.2f'%V_a_m
a1=angle(V_a.real,V_a.imag);
print 'phase angle of voltage (in Degree)=%.2f'%a1
I_a1=(E_a1-V_a)/Z_s1;
I_a1_m = math.sqrt(I_a1.real**2+I_a1.imag**2)
print '(b) magnitude of armature current of generator 1 (in Amperes)=%.2f'%(I_a1_m)
a2=angle(I_a1.real,I_a1.imag)
print 'phase angle of armature current of generator 1 (in Degree)=%.2f'%a2
I_a2=(E_a2-V_a)/Z_s2;
I_a2_m = math.sqrt(I_a2.real**2+I_a2.imag**2)
print 'magnitude of armature current of generator 2 (in Amperes)=%.2f'%I_a2_m
a3=angle(I_a2.real,I_a2.imag)
print 'phase angle of armature current of generator 2 (in Degree)=%.2f'%a3
P_o1=3*V_a*I_a1.conjugate()
P_o2=3*V_a*I_a2.conjugate()
print ' (c) Power developed of generator 1 (in Watts)=%.2f'%(P_o1.real)
print 'Power developed of generator 2 (in Watts)=%.2f'%(P_o2.real)
P_o=P_o1.real+P_o2.real;
print '(d) total power output (in Watts)=%.1f'%P_o

(a) magnitude of phase voltage (in Volts)=82.17
phase angle of voltage (in Degree)=-5.93
(b) magnitude of armature current of generator 1 (in Amperes)=9.36
phase angle of armature current of generator 1 (in Degree)=-51.17
magnitude of armature current of generator 2 (in Amperes)=7.31
phase angle of armature current of generator 2 (in Degree)=-32.06
(c) Power developed of generator 1 (in Watts)=1624.15
Power developed of generator 2 (in Watts)=1617.13
(d) total power output (in Watts)=3241.3