# Chapter 6: AC Regulators¶

## example 6.1, Page No.286¶

In [26]:
# input/output power, input power factor, average and rms vales of thyristor

import math
#variable declaration
nc = 36.0              # conduction cycles
no = 64.0              # off cycles
V = 150.0              # input voltage
Rl = 8.0               # load resistance

#calculations
#(a)
alfa = nc/(nc+no)
Vl = V*math.sqrt(alfa)
#(b)
P = (Vl**2)/Rl
#(d)
Il = Vl/Rl
va_i = V*Il
pf_i = P/va_i
#(e)
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Ip = sqrt_2*V/Rl

def f(x):
return (alfa/(2*math.pi))*Ip*(math.sin(x))
wt_lower=0
wt_upper =math.pi

val2 =Ip*math.sqrt(alfa)/2.0

#result
print("(a) rms output voltage, Vl = %.0f V\n(b) Power output = %.1f W"%(Vl,P))
print("(c) Since losses are neglected, input power = Output power = %.1f W"%(P))
print("(d) input power factor = %.1f lagging\n(e)\tPeak thyristor current = %.4f A "%(pf_i,Ip))
print("\tAverage thyristor current = %.3f A\n\tRMS thyristor current = %.2f A"%(val[0],val2))

(a) rms output voltage, Vl = 90 V
(b) Power output = 1012.5 W
(c) Since losses are neglected, input power = Output power = 1012.5 W
(d) input power factor = 0.6 lagging
(e)	Peak thyristor current = 26.5125 A
Average thyristor current = 3.038 A
RMS thyristor current = 7.95 A


## example 6.2, Page No.288¶

In [22]:
# single phase half wave regulator parameter

import math
#vaariable declaration
V = 150.0                   # input voltage
Rl = 8.0                    # load resistance
theta = 60.0                # thyristor firing angle in degrees

# Calculations
Vm =math.sqrt(2)*V
Vm = math.floor(Vm*10)/10
#(a)
Vo = Vm*(math.cos(theta*math.pi/180)-1)/(2*math.pi)
#(b)
Vl = Vm*math.sqrt(((2*math.pi)-(theta*math.pi/180)+(math.sin(2*theta*math.pi/180)/2))/(4*math.pi))
Vl = math.ceil(Vl*100)/100
#(c)
Po = (Vl**2)/Rl
#(d)
I = Vl/Rl
va = V*I
pf = Po/va
#(e)
Iavg = Vo/Rl

#Result
print("(a) Average output voltage = %.1f V\n This is negative because only a part of positive half cycle appears at the output"%Vo)
print(" whereas the whole negative cycle appears at the output.")
print("\n(b) Vl = %.2f V\n\n(c) Power output = %.2f W\n\n(d) Input pf = %.2f lagging"%(Vl,Po,pf))
print("\n(e) Average input current = Average output current = %.2f A "%(Iavg))

(a) Average output voltage = -16.9 V
This is negative because only a part of positive half cycle appears at the output
whereas the whole negative cycle appears at the output.

(b) Vl = 142.46 V

(c) Power output = 2536.86 W

(d) Input pf = 0.95 lagging

(e) Average input current = Average output current = -2.11 A


## example 6.3, Page No.293¶

In [24]:
# Single phase full wave regulator parameters

import math
#variable declaration
V = 150.0                   # input voltage
Rl = 8.0                    # load resistance
theta = 60.0                # thyristor firing angle in degrees

#calculations
Vm =math.sqrt(2)*V
Vm = math.floor(Vm*10)/10
#(a)
Vav = Vm*(math.cos(theta*math.pi/180)+1)/(math.pi)
#(b)
Vl = Vm*math.sqrt(((3.14)-(3.14/3)+(math.sin(2*theta*3.14/180)/2))/(2*3.141))
Vl = math.ceil(Vl*100)/100
#(c)
Io = Vl/Rl
Po = (Io**2)*Rl
#(d)
va = V*Io
pf = Po/va
#(e)
def f(x):
return math.sin(x)
wt_lower = math.pi/3
wt_upper = math.pi
Iavg = val[0]*Vm/(2*math.pi*Rl)

def g(x):
return math.sin(x)**2
wt_lower1 = math.pi/3
wt_upper1 = math.pi
Irms = (Vm/(Rl))*math.sqrt(val1[0]/(math.pi*2))

#Result
print("(a) Average output voltage = %.2f V\n "%Vav)
print("\n(b) Vl = %.2f V\n\n(c) Power output = %.2f W\n\n(d) Input pf = %.3f lagging"%(Vl,Po,pf))
print("\n(e) Average thyristor current= %.2f A\n    RMS thyristor current = %.2f A "%(Iavg,Irms))

#(b) For Vl calculation, value of pi is used different at different place. if math.pi is used then Vl = 134.53V
#(c) answer in the book is misprinted

(a) Average output voltage = 101.27 V

(b) Vl = 134.52 V

(c) Power output = 2261.95 W

(d) Input pf = 0.897 lagging

(e) Average thyristor current= 6.33 A
RMS thyristor current = 11.89 A


## example 6.4, Page No. 294¶

In [48]:
#  Single phase full wave ac voltage regulator

import math
#variable declaration
V = 120.0                   # input voltage
Rl = 10.0                   # load resistance
alfa = 90.0                 # thyristor firing angle in degrees

#Calculations
Vm =math.sqrt(2)*V
#Vm = math.floor(Vm*10)/10
#(a)
Vo = Vm*math.sqrt(((math.pi)-(alfa*math.pi/180)+(math.sin(2*alfa*math.pi/180)/2.0))/(2*math.pi))
#Vo = 60*math.sqrt(2)
#(b)
Il = Vo/Rl
Po = (Il**2)*Rl
VA = Il*V
pf = Po/VA
#(c)
def f(x):
return math.sin(x)
wt_lower = math.pi/2
wt_upper = math.pi
Iav = Vm*val[0]/(2*math.pi*Rl)

#(d)
Irms = Il/math.sqrt(2)
#(e)
Irmsl = Vo/Rl

#Result
print("(a) RMS output voltage = %f V\n(b) Input p.f. = %.3f lagging\n(c) Average thyristor current = %.1f A"%(Vo,pf,Iav))
print("(d) RMS thyristor current = %.1f A\n(e) RMS load current =%f A"%(Irms,Irmsl))
# Answer for "RMS output voltage" and "RMS load current" is wrong in the book.

(a) RMS output voltage = 84.852814 V
(b) Input p.f. = 0.707 lagging
(c) Average thyristor current = 2.7 A
(d) RMS thyristor current = 6.0 A
(e) RMS load current =8.485281 A


## example 6.5, Page No. 294¶

In [58]:
# rms output voltage and average power

import math
R = 400.0                  # load resistance
V = 110.0                  # input voltage
alfa = 60.0                # firing angle

# calculations
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
Vm = sqrt_2*V
Vo = Vm*math.sqrt(((math.pi)-(alfa*math.pi/180)+(math.sin(2*alfa*math.pi/180)/2.0))/(2*math.pi))
P = (Vo**2)/R

#Result
print("RMS output voltage = %.2f V\nAverage power = %.2f W"%(Vm,P))

RMS output voltage = 155.54 V
Average power = 24.33 W


## example 6.6, Page No.294¶

In [98]:
# Firing angle

import math
from numpy import poly1d
# variable declaration
a1 = 0.80          # % of maximum power value1
a2 = 0.30          # % of maximum power value2

#Calculation
#After solving equation using taylor seris of X, we got following coefficient.
P1 = poly1d([128.0/math.factorial(7),0,-32.0/math.factorial(5),0,8.0/math.factorial(3),0,0,(-2*math.pi*(1-a1))], variable = 'x')
P2 = poly1d([128.0/math.factorial(7),0,-32.0/math.factorial(5),0,8.0/math.factorial(3),0,0,(-math.pi*1.525)], variable = 'x')
# hardcoded value used to match the answer to the book
x1 = P1.r[(P1.order+1)/2]*180/math.pi
x2 = P2.r[(P1.order+1)/2]*180/math.pi
alfa1 = x1.real
alfa2 = x2.real
print("(a) alfa1 = %.1f°"%(x1.real))
print("(b) alfa2 = %.1f°"%(x2.real))

(a) alfa1 = 60.5°
(b) alfa2 = 108.6°


## example 6.7, Page No.295¶

In [26]:
# single phase AC regulator

import math
#variable declaration
V = 230.0                 # Single phase supply voltage
f = 50.0                  # supply frequency
R = 15.0                  # load resistance
alfa = 30.0               # firing angle

#calculations
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
Vm = V*sqrt_2
alfa = alfa*math.pi/180   #degree to radians
#(a)
#-Theoretical
Iavg = Vm*(1+ math.cos(alfa))/(2*math.pi*R)
Irms = (Vm/R)*math.sqrt(((math.pi - alfa)/(4*math.pi))+(math.sin(2*alfa)/(8*math.pi)))
#(b)
a1 = (Vm)*(math.cos(2*alfa)-1)/(2*math.pi)
b1 = (Vm)*((math.pi-alfa)+((math.sin(2*alfa))/2.0))/(math.pi)
Va = math.sqrt(a1**2 + b1**2)
Vrms = Va/sqrt_2
Vrms = math.floor(Vrms*1000)/1000
#(e)
P = (Vrms**2)/R
#(f)
Vl = Vm*math.sqrt((math.pi -alfa+((math.sin(2*alfa))/2.0))/(2*math.pi))
Vl =math.floor(Vl*1000)/1000
#(g)
Pt = (Vl**2)/R

#Result
print("(a) Average thyristor current = %.2f A\n RMS thyristor current = %.3f A"%(Iavg,Irms))
print("\n(b) Amplitude of fundamental component of load voltage  = %.1f V\n RMS value = %.3f V"%(math.floor(Va*10)/10,Vrms))
print("\n(c) Since load is purely resistive, the load current rises from 0 to peak value instantaneously at alfa.")
print(" Hence max.(di/dt) is infinite")
print("\n(d) Maximum forward or reverse voltage across thyristor  = %.2f V "%(Vm))#math.pi =1.414
print("\n\n(e) Power delevered to load by fundamental component of load voltage = %.2f W"%P)
print("\n\n(f) Load voltage = %.3f V"%Vl)
print("\n\n(g) Total power output = %.2f W"%Pt)

(a) Average thyristor current = 6.44 A
RMS thyristor current = 10.683 A

(b) Amplitude of fundamental component of load voltage  = 316.9 V
RMS value = 224.116 V

(c) Since load is purely resistive, the load current rises from 0 to peak value instantaneously at alfa.
Hence max.(di/dt) is infinite

(d) Maximum forward or reverse voltage across thyristor  = 325.22 V

(e) Power delevered to load by fundamental component of load voltage = 3348.53 W

(f) Load voltage = 226.625 V

(g) Total power output = 3423.93 W


## example 6.8, Page No. 300¶

In [41]:
# Single phase full wave regulator

import math
#Variable declaration
V = 150              # input voltage
R = 4                # resistance of the circuit
L = 22*10**-3        # Inductance
f = 50               # frequency
alfa = 60            # firing angle

#Calculation
#(a)
w = 2*math.pi*f
theta = (180/math.pi)*math.atan(w*L/R)
beta = 180+alfa
#(b)
alfa = alfa*math.pi/180
Vm = V*math.sqrt(2)
Vm = math.floor(Vm*10)/10
Vl = Vm*math.sqrt((math.pi-((math.sin(2*beta*math.pi/180))/2)+((math.sin(2*alfa))/2.0))/(2*math.pi))

#Result
print("(a)\ntheta = %.0f°\nAs alfa = theta, (beta-alfa) = Conduction angle= pi\ntherefore, Beta = %d°"%(theta,beta))
print("\n(b)\n Vl = %.0f V"%Vl)

(a)
theta = 60°
As alfa = theta, (beta-alfa) = Conduction angle= pi
therefore, Beta = 240°

(b)
Vl = 150 V


## example 6.9, Page No. 300¶

In [52]:
# Single phase full wave regulator parameters

import math
#Variable declaration
V = 230               # input voltage
f = 50                # frequency
R = 5                 # resistance of the circuit
L = 20*10**-3         # inductance

#Calculations
w = 2*math.pi*f
theta = (180/math.pi)*math.atan(R/(2*math.pi*f*L))
theta = math.ceil(theta*100)/100
Il = V/math.sqrt((R**2)+((w**2)*(L**2)))
Il = math.floor(Il*100)/100
P =R*Il**2
ipf = (P)/(V*Il)

#Result
print("theta = %.2f°"%theta)
print("\n(a) The minimum value of firing angle(alfa) is theta. Therefore, range of firing angle is %.2f° to 180°."%theta)
print("\n(b) Conduction period of each thyristor is 180°.")
print("\n(c)\n  Load current = %.2f A\n  Power output = %.2f W\n  Input power factor = %.3f lagging"%(Il,P,ipf))

theta = 38.52°

(a) The minimum value of firing angle(alfa) is theta. Therefore, range of firing angle is 38.52° to 180°.

(b) Conduction period of each thyristor is 180°.

(c)
Power output = 4101.25 W
Input power factor = 0.623 lagging


## example 6.10, Page No. 300¶

In [200]:
# Singal phase full wave regulator circuit parameters

import math
#Variable declaration
R = 9                    # resistance of the circuit
L = 0.03                 # inductance
V = 240                  # input voltage
f = 50                   # frequency
alfa1 = 0                # firing angle case a
alfa2 = 60               # firing angle case b
alfa3 = 90               # firing angle case c

#calculations
RbyL = R/L
alfa1 = 0*math.pi/180
alfa2 = 60*math.pi/180
alfa3 = 90*math.pi/180
alfa4 = 13.7*math.pi/180
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
w = 2*math.pi*f
Z_mag = math.sqrt((R**2)+(w**2)*(L**2))
Z_angle = math.floor((math.atan(w*L/R))*1000)/1000
x=math.floor(math.cos(Z_angle)*10000)/10000

#(a)
Il = (V*math.sqrt(2)/Z_mag)#*math.sin((w/f)-(Z_angle*math.pi/180))
Il = math.floor(Il*100)/100
P = V*Il*x/sqrt_2
#b
k1 = math.ceil((Il*math.sin(alfa2-Z_angle))*100)/100
def h(t):
return ((V*sqrt_2*math.sin(w*t*alfa2))*((Il*math.sin((w*t)+(alfa2-Z_angle)))-(k1*math.e**(-RbyL*t))))
t2 = 0.00919
t1 = 0
P2 = val[0]/0.01
#c
k2 =  math.floor((Il*math.sin(alfa3-Z_angle))*100)/100
def g(t):
return ((V*sqrt_2*math.sin(w*t*alfa3))*((Il*math.sin((w*t)+(alfa3-Z_angle)))-(k2*math.e**(-RbyL*t))))
t2 = 0.00733
t1 = 0
P3 = val2[0]/0.01

angle1 = math.ceil((Z_angle*180/math.pi)*10)/10
angle2 = (alfa2-Z_angle)*180/math.pi
angle3 = (alfa3-Z_angle)*180/math.pi

#Result
print("(a)\nCurrent waveform--> i = %.2fsin(2pi*%dt-%.1f°) A\nPower delivered = %.1f W"%(Il,f,angle1,P))
print("(b)\nCurrent waveform--> i = %.2fsin(2pi*%dt+%.1f°)-%.2fe^(-%dt) A\nPower delivered = %.1f W"%(Il,f,angle2,k1,RbyL,P2))
print("(c)\nCurrent waveform--> i = %.2fsin(2pi*%dt+%.1f°)-%.2fe^(-%dt) A\nPower delivered = %.1f W"%(Il,f,angle3,k2,RbyL,P3))
#Power answer for (b) and (c) do not match with the book

(a)
Current waveform--> i = 26.04sin(2pi*50t-46.3°) A
Power delivered = 3053.6 W
(b)
Current waveform--> i = 26.04sin(2pi*50t+13.7°)-6.17e^(-300t) A
Power delivered = 3885.4 W
(c)
Current waveform--> i = 26.04sin(2pi*50t+43.7°)-17.99e^(-300t) A
Power delivered = 2138.7 W


## example 6.11, Page No. 304¶

In [70]:
# Current and voltage ratings

import math
# variable declaration
V = 415               # 3-phase input voltage
f = 50                # frequency
P = 20*10**3          # output power
sf = 1.5              # safety factor

#Calculations
#(a)
Il = P/(math.sqrt(3)*V)
Irms = Il*sf
Irms = math.floor(Irms*100)/100
Vrms = V*sf
#(b)
Irms_thyristor = Il*sf/math.sqrt(2)

#Result
print("(a)\n Line Current = %.2f A\n RMS rating of each triac = %.2f A\n rms voltage rating = %.1f V"%(Il,Irms,Vrms))
print("\n(b)\n Line Current = %.2f A\n RMS rating of each thyristor = %.2f A\n rms voltage rating = %.1f V"%(Il,Irms_thyristor,Vrms))

(a)
Line Current = 27.82 A
RMS rating of each triac = 41.73 A
rms voltage rating = 622.5 V

(b)
Line Current = 27.82 A
RMS rating of each thyristor = 29.51 A
rms voltage rating = 622.5 V


## example 6.12, Page No.305¶

In [88]:
# output parameters of 3-phase AC regulator

import math
# variable declaration
V = 415               # 3-phase input voltage
R = 15                # load resistance per phase
alfa = 30             # firing angle

#Calculations
#(a)
Vrms = V/math.sqrt(3)
Vl = math.sqrt(3)*(math.sqrt(2)*Vrms)*math.sqrt(((math.pi/6)-((alfa*math.pi)/(180*4))+(math.sin(2*alfa*math.pi/180)/8))/(math.pi))
Vl = math.floor(Vl*10)/10
#(b)
P = (3*Vl**2)/R
#(c)
Il = Vl/R
#(d)
VA = 3*Vrms*Il
ipf = P/VA

#Result
print("(a) rms value of input phase voltage = %.1f V\n    Vl = %.1f V"%(Vrms,Vl))
print("\n(b) Output power = %.1f W or %.4f kW\n\n(c) Line Current = %.2fA\n\n(d) input p.f. = %.3f lagging"%(P,P/1000,Il,ipf))

(a) rms value of input phase voltage = 239.6 V
Vl = 234.3 V

(b) Output power = 10979.3 W or 10.9793 kW

(c) Line Current = 15.62A

(d) input p.f. = 0.978 lagging


## example 6.13, Page No. 305¶

In [109]:
# output parameters of 3-phase AC regulator

import math
# variable declaration
V = 415               # 3-phase input voltage
R = 15                # load resistance per phase
alfa = 60             # firing angle

#Calculations
#(a)
Vrms = V/math.sqrt(3)
#Vrms = math.floor(Vrms*10)/10
Vl = math.sqrt(3)*(1.414*Vrms)*math.sqrt(((3.141/6)-((alfa*3.141)/(180*4))+(math.sin(2*alfa*3.141/180)/8))/(math.pi))
#pi value = 3.141 to match the answer in the book
Vl = math.floor(Vl*100)/100
#(b)
P = (3*Vl**2)/R
#(c)
Il = Vl/R
#(d)
VA = 3*Vrms*Il
ipf = P/VA

#Result
print("(a) rms value of input phase voltage = %f V\n    Vl = %f V"%(Vrms,Vl))
print("\n(b) Output power = %.2f W or %.5f kW\n\n(c) Line Current = %.3fA\n\n(d) input p.f. = %.2f lagging"%(P,P/1000,Il,ipf))

(a) rms value of input phase voltage = 239.600362 V
Vl = 201.390000 V

(b) Output power = 8111.59 W or 8.11159 kW

(c) Line Current = 13.426A

(d) input p.f. = 0.84 lagging