# CHAPTER 2.11: LOAD FREQUENCY CONTROL AND LOAD SHARING OF POWER GENERATING SOURCES¶

## Example 2.11.1, Page number 330¶

In [1]:
#Variable declaration
rating = 1000.0        #Rating of alternator(kW)
X_fl = 100.0           #Full load speed regulation of alernator X(%)
Y_fl = 104.0           #Full load speed regulation of alernator Y(%)
X_nl = 100.0           #No load speed regulation of alernator X(%)
Y_nl = 105.0           #No load speed regulation of alernator Y(%)

#Calculation
h = 400.0/450.0                  #Point obtained from graph in textbook directly
PB = (Y_nl-X_nl)-h
PR = rating/(Y_nl-X_nl)*PB       #Load shared by machine X(kW)
QQ = (Y_fl-X_fl)-h
RQ = rating/(Y_fl-X_fl)*QQ       #Load shared by machine Y(kW)

#Result
print('Load shared by machine X, PR = %.f kW' %PR)
print('Load shared by machine Y, RQ = %.f kW' %RQ)

Load shared by machine X, PR = 822 kW
Load shared by machine Y, RQ = 778 kW
Load at which machine Y ceases to supply any portion of load = 200 kW


## Example 2.11.2, Page number 330-331¶

In [1]:
import math

#Variable declaration
kVA = 5000.0        #Rating of alternator(kVA)
N = 1500.0          #Speed(rpm)
V = 6600.0          #Voltage(V)
f = 50.0            #Frequency(Hz)
PF = 0.8            #Lagging power factor
x = 0.15            #Short circuit reactance

#Calculation
E = V/3**0.5                                                    #Phase voltage(V)
I = kVA*1000/(3**0.5*V)                                         #Full load current of alternator(A)
V_drop = E*x                                                    #Synchronous reactance drop(V)
X = V_drop/I                                                    #Synchronous reactance per phase(ohm)
P = 120*f/N                                                     #Number of poles
n = N/60                                                        #Speed(rps)
phi = math.acos(PF)*180/math.pi                                 #Φ(°)
#Case(a)
theta_a = 2.0                                                   #For a 4 pole m/c. 1 mech degree = 2 elect degree
E_s_a = E*math.sin(theta_a*math.pi/180)                         #Synchronizing voltage(V)
I_s_a = E_s_a/X                                                 #Synchronizing current(A)
P_s_a = E*I_s_a                                                 #Synchronizing power per phase(W)
P_s_a_total = 3.0*P_s_a                                         #Total synchronizing power(W)
P_s_a_total_kw = P_s_a_total/1000.0                             #Total synchronizing power(kW)
T_s_a = P_s_a_total/(2*math.pi*n)                               #Synchronizing torque(N-m)
#Case(b)
sin_phi = math.sin(phi*math.pi/180)
OB = ((E*PF)**2+(E*sin_phi+V_drop)**2)**0.5                     #Voltage(V)
E_b = OB                                                        #Voltage(V)
alpha_phi = math.atan((E*sin_phi+V_drop)/(E*PF))*180/math.pi    #α+Φ(°)
alpha = alpha_phi-phi                                           #α(°)
E_s_b = 2.0*E_b*math.sin(2.0/2*math.pi/180)                     #Synchronizing voltage(V)
I_s_b = E_s_b/X                                                 #Synchronizing current(A)
P_s_b = E*I_s_b*math.cos((alpha+1.0)*math.pi/180)               #Synchronizing power per phase(W)
P_s_b_total = 3.0*P_s_b                                         #Total synchronizing power(W)
P_s_b_total_kw = P_s_b_total/1000.0                             #Total synchronizing power(kW)
T_s_b = P_s_b_total/(2*math.pi*n)                               #Synchronizing torque(N-m)

#Result
print('Case(a): Synchronizing power for no-load, P_s = %.1f kW' %P_s_a_total_kw)
print('         Synchronizing torque for no-load, T_s = %.f N-m' %T_s_a)
print('Case(b): Synchronizing power at full-load, P_s = %.1f kW' %P_s_b_total_kw)
print('         Synchronizing torque at full-load, T_s = %.f N-m' %T_s_b)
print('\nNOTE: ERROR: Calculation mistakes in textbook')

Case(a): Synchronizing power for no-load, P_s = 1163.3 kW
Synchronizing torque for no-load, T_s = 7406 N-m
Case(b): Synchronizing power at full-load, P_s = 1265.6 kW
Synchronizing torque at full-load, T_s = 8057 N-m

NOTE: ERROR: Calculation mistakes in textbook


## Example 2.11.3, Page number 331-332¶

In [1]:
#Variable declaration
V = 6600.0             #Voltage(V)
R = 0.045              #Resistance(ohm)
X = 0.45               #Reactance(ohm)
PF = 0.8               #Lagging power factor
I_a = 437.5            #Armature current(A)

#Calculation
I_working = PF*I                                 #Working component of current(A)
I_watless = (1-PF**2)**0.5*I                     #Watless component of current(A)
I_second = (I_a**2+I_watless**2)**0.5            #Load current supplied by second alternator(A)
PF_second = I_a/I_second                         #Lagging power factor of second alternator
V_ph = V/3**0.5                                  #Terminal voltage per phase(V)
I_R = I_second*R                                 #Voltage drop due to resistance(V)
I_X = I_second*X                                 #Voltage drop due to reactance(V)
sin_phi_second = (1-PF_second**2)**0.5
E = ((V_ph+I_R*PF_second+I_X*sin_phi_second)**2+(I_X*PF_second-I_R*sin_phi_second)**2)**0.5   #EMF of the alternator(V/phase)
E_ll = 3**0.5*E                                  #Line-to-line EMF of the alternator(V)

#Result
print('Armature current of other alternator = %.1f A' %I_second)
print('e.m.f of other alternator = %.f V (line-to-line)' %E_ll)
print('Power factor of other alternator = %.3f (lagging)' %PF_second)

Armature current of other alternator = 788.6 A
e.m.f of other alternator = 7151 V (line-to-line)
Power factor of other alternator = 0.555 (lagging)


## Example 2.11.4, Page number 332-333¶

In [1]:
#Variable declaration
X = 10.0               #Reactance(ohm)
I_a = 220.0            #Armature current(A)
PF = 1.0               #Unity power factor
V = 11000.0            #Phase voltage(V)
emf_raised = 0.2       #EMF rasied by 20%

#Calculation
I_X = I_a*X                        #Reactance drop(V)
E_0 = (V**2+I_X**2)**0.5           #EMF(V)
E_00 = (1+emf_raised)*E_0          #New value of induced emf(V)
U = ((E_00**2-I_X**2)**0.5-V)/X    #Current(A)
I_1 = (I_a**2+U**2)**0.5           #Current(A)
PF_1 = I_a/I_1                     #Lagging power factor
I_X_2 = (E_00**2+V**2)**0.5        #Reactance drop(V)
I_2 = I_X_2/X                      #Current corresponding to this drop(A)
PF_2 = E_00/I_X_2                  #Leading power factor
P_max = V*I_2*PF_2/1000            #Maximum power output(kW)

#Result
print('New value of machine current = %.1f A' %I_1)
print('New vaue of power factor, p.f = %.4f (lagging)' %PF_1)
print('Power output at which alternator break from synchronism = %.f kW' %P_max)
print('Current corresponding to maximum load = %.f A' %I_2)
print('\nNOTE: ERROR: Calculation mistakes in the textbook solution')

New value of machine current = 316.9 A
New vaue of power factor, p.f = 0.6943 (lagging)
Power output at which alternator break from synchronism = 14808 kW
Current corresponding to maximum load = 1738 A

NOTE: ERROR: Calculation mistakes in the textbook solution


## Example 2.11.5, Page number 333¶

In [1]:
import math

#Variable declaration
V = 10000.0            #Voltage(V)
rating = 10000.0       #Full load rating(kW)
V_drop_per = 0.2       #Voltage drop of 20% for 10000 kW

#Calculation
V_drop = V_drop_per*rating                    #Voltage drop(V)
sin_theta_2 = (V_drop/2)/V                    #Sin(θ/2)
theta_2 = math.asin(sin_theta_2)*180/math.pi  #θ/2(°)
theta = 2.0*theta_2                           #Phase angle between busbar sections, θ(°)

#Result
print('Phase angle between busbar sections, θ = %.2f° ' %theta)
print('\nNOTE: ERROR: Calculation mistakes in the textbook solution')

Phase angle between busbar sections, θ = 11.48°

NOTE: ERROR: Calculation mistakes in the textbook solution


## Example 2.11.6, Page number 334¶

In [1]:
import math
import cmath

#Variable declaration
V = 11000.0             #Voltage(V)
PF_1 = 1.0              #Unity power factor
PF_2 = 0.8              #Lagging power factor
R = 0.5                 #Resistance(ohm/phase)
X = 0.8                 #Reactance(ohm/phase)

#Calculation
I_2 = load_2*1000/(3**0.5*V*PF_2)*cmath.exp(1j*-math.acos(PF_2))   #Current supplied by local generators(A)
I_3 = I_1-I_2                                                      #Current through interconnector(A)
angle_I_3 = cmath.phase(I_3)*180/math.pi                           #Current through interconnector leads reference phasor by angle(°)
V_drop = (R+1j*X)*I_3                                              #Voltage drop across interconnector(V)
V_ph = V/3**0.5                                                    #Phase voltage(V)
V_S = V_ph+V_drop                                                  #Sending end voltage(V/phase)
V_S_ll = 3**0.5*V_S                                                #Sending end voltage(V)
angle_V_S_ll = cmath.phase(V_S_ll)*180/math.pi                     #Angle of sending end voltage(°)
PF_S = math.cos((angle_I_3-angle_V_S_ll)*math.pi/180)              #Power factor at sending station

#Result
print('Voltage at this latter station = %.f∠%.2f° V (line-to-line)' %(abs(V_S_ll),angle_V_S_ll))
print('Power factor at this latter station = %.4f (leading)' %PF_S)

Voltage at this latter station = 11168∠5.89° V (line-to-line)
Power factor at this latter station = 0.9356 (leading)


## Example 2.11.7, Page number 334¶

In [1]:
import math
import cmath

#Variable declaration
V = 33000.0             #Voltage(V)
R = 0.7                 #Resistance(ohm/phase)
X = 3.5                 #Reactance(ohm/phase)
PF_1 = 0.8              #Lagging power factor
PF_2 = 0.707            #Lagging power factor

#Calculation
V_ph = V/3**0.5                                                     #Phase voltage(V)
I_3 = I_1-I_2                                                       #Current through interconnector(A)
angle_I_3 = cmath.phase(I_3)*180/math.pi                            #Current through interconnector leads reference phasor by angle(°)
V_drop = (R+1j*X)*I_3                                               #Voltage drop across interconnector(V)
V_Y = V_ph-V_drop                                                   #Voltage at Y(V)
angle_V_Y = cmath.phase(V_Y)*180/math.pi                            #Angle of voltage at Y(°)
phase_diff = angle_I_3-angle_V_Y                                    #Phase difference b/w Y_Y and I_3(°)
PF_Y = math.cos(phase_diff*math.pi/180)                             #Power factor of current received by Y
P_Y = 3*abs(V_Y*I_3)*PF_Y/1000.0                                    #Power received by station Y(kW)
phase_XY = abs(angle_V_Y)                                           #Phase angle b/w voltages of X & Y(°)

#Result
print('Load received from station X to station Y = %.f kW' %P_Y)
print('Phase difference between voltage of X & Y = %.2f° (lagging)' %phase_XY)
print('\nNOTE: Changes in the obtained answer from that of textbook is due to more precision here')

Load received from station X to station Y = 19727 kW
Phase difference between voltage of X & Y = 3.60° (lagging)

NOTE: Changes in the obtained answer from that of textbook is due to more precision here


## Example 2.11.8, Page number 335¶

In [1]:
import math
import cmath

#Variable declaration
V_tie = 11000.0         #Tie line Voltage(V)
Z = (3.5+1j*7.0)        #Impedance of tie line(ohm/conductor)
V = 6600.0              #Bus bar voltage(V)
Z_per = (2.5+1j*7.5)    #Percentage impedance on 1000kVA rating
kVA = 2500.0            #Load receieved by other(kVA)

#Calculation
V_ph = V/3**0.5                            #Phase voltage(V)
I_fl_LV = 100.0*V_tie/V_ph                 #LV side Full load current of each transformer(A)
R_eq = V_ph*Z_per.real/(100*I_fl_LV)       #Equivalent resistance of transformer(ohm/phase)
X_eq = 3.0*R_eq                            #Equivalent reactance of transformer(ohm/phase)
R_phase = Z.real*(V/V_tie)**2              #Resistance of line per phase(ohm)
X_phase = Z.imag*(V/V_tie)**2              #Resistance of line per phase(ohm)
R_total = 2.0*R_eq+R_phase                 #Total resistance per phase(ohm)
X_total = 2.0*X_eq+X_phase                 #Total resistance per phase(ohm)
Z_total = R_total+1j*X_total               #Total impedance(ohm/phase)
V_drop = I*Z_total                         #Voltage drop per phase(V)
V_A = V_ph
V_AA = V_A+V_drop                          #Sending end voltage per phase(V)
V_increase = abs(V_AA)-V_A                 #Increase in voltage required(V/phase)
percentage_increase = V_increase/V_A*100   #Percentage increase required(%)
phase_diff = cmath.phase(V_AA)*180/math.pi #Angle at which V_A & V_B are displaced(°)

#Result
print('Case(a): Percentage increase in voltage = %.2f percent' %percentage_increase)
print('Case(b): Phase angle difference between the two busbar voltages = %.2f° ' %phase_diff)
print('\nNOTE: ERROR: Several calculation mistakes in the textbook')

Case(a): Percentage increase in voltage = 13.98 percent
Case(b): Phase angle difference between the two busbar voltages = 13.10°

NOTE: ERROR: Several calculation mistakes in the textbook


## Example 2.11.9, Page number 335-336¶

In [1]:
import math
import cmath

#Variable declaration
X = 2.80             #Combined reactance(ohm/phase)
PF_1 = 0.9           #Lagging power factor
V = 11000.0          #Voltage(V)
PF_2 = 0.75          #Lagging power factor

#Calculation
V_ph = V/3**0.5                                                         #Phase voltage(V)
Y_1 = 220.443/V_ph                                                      #Solved manually referring textbook
X_1 = (1-Y_1**2)**0.5
angle_1 = math.atan(Y_1/X_1)*180/math.pi                                #Phasor lags by an angle(°)
IA_Y = (6849.09119318-V_ph*X_1)/X                                       #Current(A)
Y_X = IA_Y/IA_X
angle_2 = math.atan(Y_X)*180/math.pi                                    #Angle by which I_A lags behind V_A(°)
PF_A = math.cos(angle_2*math.pi/180)                                    #Power factor of station A
angle_3 = (math.acos(PF_2)*180/math.pi)+angle_1                         #Angle by which I_2 lags V_A(°)
I = 78.7295821622-1j*(IA_Y-177.942225747)                               #Current(A)
I_B = I_22-I                                                            #Current(A)
angle_4 = abs(cmath.phase(I_B)*180/math.pi)-angle_1                     #Angle by which I_B lags behind V_B(°)
PF_B = math.cos(angle_4*math.pi/180)                                    #Power factor of station B

#Result
print('Power factor of station A = %.4f (lagging)' %PF_A)
print('Power factor of station B = %.4f (lagging)' %PF_B)
print('Phase angle between two bus bar voltages = %.f° (V_B lagging V_A)' %angle_1)

Power factor of station A = 0.9279 (lagging)
Power factor of station B = 0.6929 (lagging)
Phase angle between two bus bar voltages = 2° (V_B lagging V_A)


## Example 2.11.10, Page number 336¶

In [1]:
import math
import cmath

#Variable declaration
V = 33000.0           #Voltage(V)
PF_1 = 0.8            #Lagging power factor
R = 1.6               #Resistance of feeder(ohm/phase)
X = 2.5               #Reactance of feeder(ohm/phase)
PF_2 = 0.72           #Lagging power factor

#Calculation
I = load_1*1000/(3**0.5*V*PF_1)*cmath.exp(1j*-math.acos(PF_1))       #Total line current(A)
I_1 = load_2*1000/(3**0.5*V*PF_2)*cmath.exp(1j*-math.acos(PF_2))     #Line current of first feeder(A)
I_2 = I-I_1                                                          #Line current of first feeder(A)
Z_1 = complex(1.6,2.5)                                               #Impedance of first feeder(ohm)
Z_2 = I_1*Z_1/I_2                                                    #Impedance of second feeder(ohm)

#Result
print('Impedance of second feeder, Z_2 = %.2f∠%.1f° ohm' %(abs(Z_2),cmath.phase(Z_2)*180/math.pi))
print('\nNOTE: ERROR: Changes in the obtained answer from that of textbook is due to wrong values of substitution')

Impedance of second feeder, Z_2 = 2.87∠43.5° ohm

NOTE: ERROR: Changes in the obtained answer from that of textbook is due to wrong values of substitution


## Example 2.11.11, Page number 337¶

In [1]:
#Variable declaration
P = 9.0                   #Load supplied from substation(MW)
V = 33000.0               #Voltage(V)
PF_1 = 1.0                #Unity power factor
Z_A = complex(2.0,8.0)    #Impedance of circuit A(ohm)
Z_B = complex(4.0,4.0)    #Impedance of circuit B(ohm)

#Calculation
V_ph = V/3**0.5                                 #Voltage at receiving end per phase(V)
P_A = 1.0/3*P                                   #Power supplied by line A(MW)
P_B = 2.0/3*P                                   #Power supplied by line B(MW)
I_A = P_A*10**6/(3**0.5*V)                      #Current through line A(A)
I_B = P_B*10**6/(3**0.5*V)                      #Current through line B(A)
IA_ZA_drop = I_A*Z_A                            #I_A Z_A drop(V/phase)
IB_ZB_drop = I_B*Z_B                            #I_B Z_B drop(V/phase)
phase_boost = IB_ZB_drop.real-IA_ZA_drop.real   #Voltage in phase boost(V/phase)
constant_P = V_ph+IA_ZA_drop                    #Assumed that sending end voltage at P is kept constant(V/phase)

#Result
print('Voltage in-phase boost = %.2f V/phase' %phase_boost)

Voltage in-phase boost = 314.92 V/phase
Voltage in quadrature boost = 0 V/phase


## Example 2.11.12, Page number 337¶

In [1]:
#Variable declaration
cap_A = 15000.0              #Capacity of station A(kW)
cap_B = 10000.0              #Capacity of station B(kW)
cap_C = 2000.0               #Capacity of station C(kW)
speed_reg_A = 2.4/100        #Speed regulation of A
speed_reg_B = 3.2/100        #Speed regulation of B
slip_C = 4.5/100             #Full load slip

#Calculation
#Case(a)
speed_A = speed_reg_A/cap_A                                       #% of speed drop for A
speed_C = slip_C/cap_C                                            #% of speed drop for C
speed_B = speed_reg_B/cap_B                                       #% of speed drop for B
#Case(b)

#Result
print('Case(a): Load on C when local load of B is 10000 kW and A has no load, X = %.f kW' %X)
print('Case(b): Load on C when both station have local loads of 10000 kW, Y = %.f kW' %Y)

Case(a): Load on C when local load of B is 10000 kW and A has no load, X = 1172 kW
Case(b): Load on C when both station have local loads of 10000 kW, Y = 586 kW


## Example 2.11.13, Page number 337-338¶

In [1]:
import math

#Variable declaration
l = 20.0                 #Length of cable(km)
r = 0.248                #Resistance(ohm/km)
x = 0.50*10**-3          #Inductance(H/m)
V_gen = 6600.0           #Generation voltage(V)
f = 50.0                 #Frequency(Hz)
V = 33000.0              #Transmission voltage(V)
rating = 10.0            #Transformer rating(MVA)
loss_cu = 100.0          #Copper loss at full load(kW)
x_tr = 2.5/100           #Transformer reactance
PF = 0.71                #Lagging power factor

#Calculation
R = l*r                                                         #Resistance of the cable(ohm)
I_fl = rating*10**6/(3**0.5*V)                                  #Transformer current at full load(A)
R_eq = loss_cu*1000/(3*I_fl**2)                                 #Equivalent resistance per phase of transformer(ohm)
R_total_hv = R+2.0*R_eq                                         #Total resistance per conductor in terms of hv side(ohm)
X = 2.0*math.pi*f*l*x                                           #Reactance of cable per conductor(ohm)
per_X_tr = V/3**0.5*x_tr/I_fl                                   #% reactance of transformer(ohm)
X_total_hv = X+2.0*per_X_tr                                     #Total reactance per conductor in terms of hv side(ohm)
I = load*10**6/(3**0.5*V*PF)                                    #Line current at receiving end(A)
IR = I*R_total_hv                                               #IR drop(V)
IX = I*X_total_hv                                               #IX drop(V)
E_r = V/3**0.5                                                  #Phase voltage at station B(V)
cos_phi_r = PF
sin_phi_r = (1-PF**2)**0.5
E_s = ((E_r*cos_phi_r+IR)**2+(E_r*sin_phi_r+IX)**2)**0.5/1000   #Sending end voltage(kV)
E_s_ll = 3**0.5*E_s                                             #Sending end line voltage(kV)
V_booster = 3**0.5*(E_s-E_r/1000)                               #Booster voltage between lines(kV)
tan_phi_s = (E_r*sin_phi_r+IX)/(E_r*cos_phi_r+IR)               #tanΦ_s
phi_s = math.atan(tan_phi_s)*180/math.pi                        #Φ_s(°)
cos_phi_s = math.cos(phi_s*math.pi/180)                         #cosΦ_s
P_s = 3.0*E_s*I*cos_phi_s                                       #Power at sending end(kW)

Loss in the interconnector as a percentage of power received = 9.752 percent