Chapter 3: Controlled Rectifiers

example 3.1, Page No. 127

In [1]:
print("Theoretical example")

Theoretical example

example 3.2, Page No. 129

In [2]:
print("Theoretical example")

Theoretical example

example 3.3, Page No. 130

In [6]:
# Half wave diode rectifier

import math
from scipy.integrate import quad
#Variable declaration
V = 12.0                # Voltage of the battery to be charged
B = 150.0               # battery capacity in Wh
I = 4.0                 # average current requirement
t = 4.0                 # transformer primary to secondary ratio 
Vi = 230.0              # voltage at transformer primary

# Calculations
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vp = Vi*sqrt_2/t
#(a)
alfa = (180/math.pi)*(math.asin(V/Vp))
ang_c = (180-alfa)-alfa
ang_c = math.floor(ang_c*100)/100
#(b)
def f(wt):
    return ((Vp*math.sin(wt))-V)/(2*math.pi*I)
wt_lower=(alfa*math.pi/180)
wt_upper =math.pi-(alfa*math.pi/180)
val1 = quad(f,wt_lower,wt_upper)
R = val1[0]
R = math.floor(R*100)/100
#(c)
def g(wt):
    return (((Vp*math.sin(wt))-V)**2)/(2*math.pi*(R**2))
val2 = quad(g,wt_lower,wt_upper)
Irms = val2[0]
Irms = math.floor(math.sqrt(Irms)*100)/100
P = (Irms**2)*R
#(d)
T = B/(V*I)
#(e)
eff = (V*I)/((V*I)+P)
#(f)
PIV = Vp+V

#Results
print("(a) Conduction angle = %.2f°\n(b) R = %.2f ohm\n(c) Irms = %.2f A\n    Resistor power rating = %.1f W"%(ang_c,R,Irms,P))
print("(d) Time of charging = %.3f hours\n(e) Rectifier efficiency = %.4f or %.2f%%\n(f) PIV = %.3f V"%(T,eff,eff*100,PIV))

(a) Conduction angle = 163.02°
(b) R = 5.04 ohm
(c) Irms = 6.58 A
    Resistor power rating = 218.2 W
(d) Time of charging = 3.125 hours
(e) Rectifier efficiency = 0.1803 or 18.03%
(f) PIV = 93.305 V

example 3.4, Page No. 131

In [39]:
#Full wave centre tapped rectifier

import math
# Variable declaration
Vm = 100.0             # transformer secondary voltage from mid point to each end
R = 5.0                # resistance

#Calculation
#(b)
Idc = 2*Vm/(math.pi*R)
Idc = math.floor(Idc*1000)/1000
Vdc = Idc*R
Irms = 0.707*Vm/R
Pdc = R*Idc**2
Pdc = math.ceil(Pdc*100)/100
Pac = R*Irms**2
Pac = math.ceil(Pac*10)/10
eff = Pdc/Pac
FF = math.floor(((0.707*Vm*math.pi)/(2*Vm))*100)/100
RF = math.sqrt((FF**2)-1)
TUF = (((2/math.pi)**2)/(2*0.707*0.5))*100
PIV =2*Vm

# Result
print("Idc = %.3f A\nVdc = %.2f V\nIrms = %.2f A\nPdc = %.2f\nPac = %.1f\nEfficiency = %.3f"%(Idc,Vdc,Irms,Pdc,Pac,eff))
print("FF = %.2f\nRF = %.3f\nTUF = %.2f%%\nPIV = %d\nCF = %f"%(FF,RF,TUF,PIV,math.sqrt(2)))

Idc = 12.732 A
Vdc = 63.66 V
Irms = 14.14 A
Pdc = 810.52
Pac = 999.7
Efficiency = 0.811
FF = 1.11
RF = 0.482
TUF = 57.32%
PIV = 200
CF = 1.414214

example 3.5, Page No.133

In [1]:
print("Theoretical example")

Theoretical example

example 3.6, Page No.135

In [43]:
# Single phase diode bridge rectifier

import math
#Variable declaration
Vm = 100.0             # Peak input voltage
R = 5.0                # load resistance

#Calculation
#(b)
Idc = 2*Vm/(math.pi*R)
Idc = math.floor(Idc*1000)/1000
Vdc = Idc*R
Irms = 0.707*Vm/R
Pdc = R*Idc**2
Pdc = math.ceil(Pdc*100)/100
Pac = R*Irms**2
Pac = math.ceil(Pac*10)/10
eff = Pdc/Pac
FF = math.floor(((0.707*Vm*math.pi)/(2*Vm))*100)/100
RF = math.sqrt((FF**2)-1)
PIV =Vm

# Result
print("Idc = %.3f A\nVdc = %.2f V\nIrms = %.2f A\nPdc = %.2f\nPac = %.1f\nEfficiency = %.3f"%(Idc,Vdc,Irms,Pdc,Pac,eff))
print("FF = %.2f\nRF = %.3f\nPIV = %d\nCF = %f"%(FF,RF,PIV,math.sqrt(2)))

Idc = 12.732 A
Vdc = 63.66 V
Irms = 14.14 A
Pdc = 810.52
Pac = 999.7
Efficiency = 0.811
FF = 1.11
RF = 0.482
PIV = 100
CF = 1.414214

example 3.7, Page No.135

In [2]:
print("Theoretical example")

Theoretical example

example 3.8, Page No.138

In [49]:
# Single phase half wave rectifier circuit

import math
# Variable declaration
Vm = 400                # amplitude of output sine wave
alfa = 30               # thyristor firing angle
R = 50                  # Load resistance

#Calculations
alfa = alfa*math.pi/180
Vdc = Vm*(1+math.cos(alfa))/(2*math.pi)
I = Vdc/R
Vrms = Vm*math.sqrt(((math.pi-alfa)/(4*math.pi))+(math.sin(2*alfa)/(8*math.pi)))
Irms  = Vrms/R

#Result
print("Average DC voltage = %.1f V\nAverage load current = %.3f A"%(Vdc,I))
print("RMS voltage = %.1f V\nRMS current = %.3f A"%(Vrms,Irms))

Average DC voltage = 118.8 V
Average load current = 2.376 A
RMS voltage = 197.1 V
RMS current = 3.942 A

example 3.9, Page No. 138

In [5]:
# Average current in the circuit

import math
from scipy.integrate import quad
#Variable declaration
Vm = 100.0                   # peak input voltage
V = 50.0                     # voltage of battery to be charged
R = 10.0                     # load resistance

#Calculations
wt = math.asin(V/Vm)
wt2= math.pi-wt
def f(wt):
    return ((Vm*math.sin(wt))-V)/(2*math.pi*R)
wt_lower=wt
wt_upper =wt2
val = quad(f,wt_lower,wt_upper)
i = val[0]

#Result
print("Average current in the circuit = %.2f A"%i)

Average current in the circuit = 1.09 A

example 3.10, Page No. 139

In [10]:
# Average current

import math
from scipy.integrate import quad
#Variable declaration
Vm = 110.0                # peak input voltage
f = 50.0                 # input frequency
Ra = 10.0                # motor armature resistance
E = 55.5                 # back emf of the motor

#Calculations
wt = math.asin(E/(Vm*math.sqrt(2)))
wt2 = math.pi-wt
def f(wt):
    return ((math.sqrt(2)*Vm*math.sin(wt))-E)/(2*math.pi*Ra)
wt_lower=wt
wt_upper =wt2
val = quad(f,wt_lower,wt_upper)
i = val[0]

#Result
print("Average current in the circuit = %.3f A"%i)

Average current in the circuit = 2.495 A

example 3.11, Page No. 139

In [31]:
# Single phase half wave rectifier

import math
# Variable declaration
R = 15.0             # load resistance
V = 230.0            # supply voltage
alfa = math.pi/2     # firing angle

#Calculations
Vm = math.sqrt(2)*V
Vm = math.floor(Vm*10)/10
#(a)
Vdc = Vm*(1+math.cos(alfa))/(2*math.pi)
Vdc = math.ceil(Vdc*100)/100
Idc = Vdc/R
Idc = math.floor(Idc*100)/100
Vrms = Vm*math.sqrt(((math.pi-alfa)/(4*math.pi))+((math.sin(2*alfa))/(8*math.pi)))
Vrms = math.ceil(Vrms*100)/100
Irms =Vrms/R
Irms = math.floor(Irms*100)/100
#(b)
Pdc = Vdc*Idc
Pac = Vrms*Irms
eff = Pdc/Pac
#(c)
FF = Vrms/Vdc
RF = math.sqrt((FF**2)-1)
#(d)
VA = V*Irms
TUF = Pdc/VA
#(e)
PIV = Vm

#Result
print("(a)\nVdc = %.2f V\nIdc = %.2fA\nVrms = %.2f V\nIrms = %.2f A"%(Vdc,Idc,Vrms,Irms))
print("\n(b)\nRectification Efficiency = %.3f"%eff)
print("\n(c)\nForm Factor = %.2f\nRipple Factor = %.3f\n\n(d)\nTransformer utilization factor =%.4f\n\n(e)PIV = %.1f V"%(FF,RF,TUF,PIV))

(a)
Vdc = 51.76 V
Idc = 3.45A
Vrms = 114.98 V
Irms = 7.66 A

(b)
Rectification Efficiency = 0.203

(c)
Form Factor = 2.22
Ripple Factor = 1.984

(d)
Transformer utilization factor =0.1014

(e)PIV = 325.2 V

example 3.12, Page No.146

In [40]:
# Single phase full wave rectifier

import math
#Variable declaration
V = 150.0                 # input rms value
R = 30.0                  # load resistance
alfa =(math.pi/180)*45    # firing angle

#Calculations
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vdc = V*sqrt_2*(1+math.cos(alfa))/math.pi
I = Vdc/R
Vrms = V*sqrt_2*math.sqrt(((math.pi-alfa)/(2*math.pi))+((math.sin(2*alfa))/(4*math.pi)))
Irms =Vrms/R

#Result
print("Vdc = %.2f V\nAverage load current = %.2f A\nVrms = %d V\nRMS load current = %.3f A"%(Vdc,I,Vrms,Irms))

Vdc = 115.25 V
Average load current = 3.84 A
Vrms = 143 V
RMS load current = 4.767 A

example 3.13, Page No. 146

In [79]:
# Transformer and thyristor parameters

import math
#Variable declaration
V = 230.0                 # input to transformer primary
f = 50.0                  # input frequency
Vdc = 100.0                # Average values of load voltage
Idc = 15.0                 # Average value of load current
alfa = 30*(math.pi/180)   # firing angle
d = 1.7                   # drop across thyristor


#caculatios
#(a)
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = ((Vdc+d)*math.pi)/(2*math.cos(alfa))
Vm = math.floor(Vm*100)/100
Vrms = Vm/1.4109#math.sqrt(2)::to match the ans in book
N = V/Vrms
#(b)
Irms = math.sqrt((Idc**2)/2)
Irms = math.ceil(Irms*100)/100
Tr = 2*Vrms*Irms

#(c)
PIV = 2*Vm
#(d)
It = Irms

#Result
print("(a)\nVm = %.2f V\nRMS voltage of each half cycle of secondary = %.2f V\nTurn ratio of transformer = %.2f"%(Vm,Vrms,N))
print("\n(b)Transformer VA rating = %.1f VA\n\n(c)PIV = %.2f V\n\n(d)RMS value of thyristor current = %.2f A"%(Tr,PIV,It))

(a)
Vm = 184.46 V
RMS voltage of each half cycle of secondary = 130.74 V
Turn ratio of transformer = 1.76

(b)Transformer VA rating = 2774.3 VA

(c)PIV = 368.92 V

(d)RMS value of thyristor current = 10.61 A

example 3.14, Page No.148

In [7]:
# thyristor rated voltage

import math
#Variable declaration
P = 10.0*10**3             # rectifier powwer rating
I = 50.0                   # thyristor current rating
sf = 2                     # safety factor

#Calculations
Idc = I
#(a)
Vdc = P/Idc
Vm = Vdc*math.pi/2
PIV = 2*Vm
Vt = 2*PIV
#(a)
Vt2 = 2*Vm

#Result
print("(a) Full wave centre tapped recifier:\n    Thyristor voltage rating = %.2f V"%Vt)
print("\n(b) Full wave bridge rectifier:\n    Thyristor voltage rating = %.2f V"%Vt2)

(a) Full wave centre tapped recifier:
    Thyristor voltage rating = 1256.64 V

(b) Full wave bridge rectifier:
    Thyristor voltage rating = 628.32 V

example 3.15, Page No. 149

In [3]:
# output voltage, firing angle, load current

import math
from numpy import poly1d
#variable declaaration
V = 230.0                # input voltage
P = 1000.0               # output power rating
Pl = 800.0               # Actual power delivered

#Calculations
#(a)
Vrms = math.sqrt((Pl*V**2)/P)
Vrms = math.ceil(Vrms*100)/100
#(b)
#After solving equation using taylor seris of X, we got following coefficient. 
P = poly1d([128.0/math.factorial(7),0,-32.0/math.factorial(5),0,8.0/math.factorial(3),0,0,(-2*math.pi*(1-(Vrms/V)**2))], variable = 'x')
x = P.r[(P.order+1)/2]*180/math.pi
alfa = math.ceil(x.real)
#(c)
I = Pl/Vrms

#Result
print("(a) Vrms = %.2f V\n(b) firing angle = %.0f°\n(c) Load current(rms value) = %.3f A"%(Vrms,alfa,I))

(a) Vrms = 205.72 V
(b) firing angle = 61°
(c) Load current(rms value) = 3.889 A

example 3.16, Page No.149

In [18]:
# Average power output

import math
#Variable declaration
V = 800.0               # thyristor peak voltage rating
I = 30.0                # average forward current
sf = 2.5                # safety factor

#Calculations
#(a)
Vm = V/(2*sf)
Vdc = 2*Vm/math.pi
Vdc = math.ceil(Vdc*100)/100
Idc = I/sf
P = Idc*Vdc
#(b)
Vm2 = V/sf
Vdc2 = 2*Vm2/math.pi
Vdc2 = math.ceil(Vdc2*100)/100
Idc2 = I/sf
P2 = Idc2*Vdc2

#Result
print("(a) In a mid point converter:\n    Average output power = %.2f W"%P)
print("(b) In a Bridge converter:\n    Average output power = %.2f W"%P2)

(a) In a mid point converter:
    Average output power = 1222.32 W
(b) In a Bridge converter:
    Average output power = 2444.64 W

example 3.17, Page No.150

In [35]:
# Bridge converter parameters

import math
from scipy.integrate import quad
#Variable declaration
V = 230.0              # input voltage
R = 10.0               # load resistance
alfa = 30*math.pi/180  # firing angle

#Calculations
#(b)
Vm = math.sqrt(2)*V
def f(wt):
    return math.sin(wt)
wt_lower1 = alfa
wt_upper1 = math.pi
wt_lower2 = math.pi
wt_upper2 = 2*math.pi
val1 = quad(f,wt_lower1,wt_upper1)
val2 = quad(f,wt_lower2,wt_upper2)
Vo =math.floor(((Vm/(2*math.pi))*(val1[0]-val2[0]))*10)/10
I = Vo/R
P = Vo*I
#result
print("DC power output = %.3f W"%P)

DC power output = 4004.001 W

example 3.18, Page No. 150

In [51]:
# output voltage and power

import math
#Variable declaration
V = 230.0              # input voltage
R = 10.0               # load resistance

#Calculations
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vo = 2*sqrt_2*V/math.pi
Vo = math.floor(Vo*100)/100
I = Vo/R
P = Vo*I

#Result
print("DC power = %.2f W"%P)

DC power = 4286.56 W

example 3.19, Page No.154

In [67]:
# Single phase bridge converter circuit

import math
#Variable declaration
V = 230.0                       # input voltage
f = 50.0                        # input frequency
I = 15.0                        # constant load current
R = 0.5                         # load resistance
L = 0.3                         # inductance
E1 = 100                        # back emf for case 1
E2 = -100                       # back emf for case 2  

#Calculations
#(a)
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = sqrt_2*V
alfa1 = (math.acos((E1+I*R)*math.pi/(2*Vm)))*(180/math.pi)
#(b)
alfa2 = (math.acos((E2+I*R)*math.pi/(2*Vm)))*(180/math.pi)
#(c)
OP1 = (E1*I)+(R*I**2)
OP2 = (E2*I)+(R*I**2)
IP = V*I
pf1 = OP1/IP
pf2 = -OP2/IP
print("(a) Firing angle = %.2f°"%(math.ceil(alfa1*100)/100))
print("(b) Firing angle = %.2f°"%alfa2)#Answer in the book is wrong
print("(c) when E = %d : input power factor= %.3f lagging\n    When E = %d: input power factor= %.3f lagging"%(E1,pf1,E2,pf2)) 

(a) Firing angle = 58.73°
(b) Firing angle = 116.54°
(c) when E = 100 : input power factor= 0.467 lagging
    When E = -100: input power factor= 0.402 lagging

example 3.20, Page No.155

In [69]:
# Average load current

import math
#Variable declaration
V = 230.0                  # input voltage
f = 50.0                   # frequency
R = 5.0                    # load resistance
L = 8*10**-3               # inductance
E = 50.0                   # back emf
alfa = 40*(math.pi/180)    # firing angle

#Calculations
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = sqrt_2*V
I = ((2*Vm*math.cos(alfa)/math.pi)-E)/R

#Result
print("Average load current = %.2f A"%I)

Average load current = 21.72 A

example 3.21, Page No. 155

In [80]:
# Transformer and thyristor parameters for full bridge circuit

import math
#Variable declaration
V = 230.0                 # input to transformer primary
f = 50.0                  # input frequency
Vdc = 100.0               # Average values of load voltage
Idc = 15.0                # Average value of load current
alfa = 30*(math.pi/180)   # firing angle
d = 1.7                   # drop across thyristor


#caculatios
#(a)
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = ((Vdc+2*d)*math.pi)/(2*math.cos(alfa))
Vrms = Vm/sqrt_2
N = V/Vrms
#(b)
Irms = Idc
Tr = Vrms*Irms
#(c)
PIV = Vm
#(d)
Itrms = Idc/sqrt_2

#Result
print("(a)\nVm = %.2f V\nRMS voltage of secondary = %.2f V\nTurn ratio of transformer = %.3f"%(Vm,Vrms,N))
print("\n(b)Transformer VA rating = %.1f VA\n\n(c) PIV = %.2f V\n\n(d)RMS value of thyristor current = %.2f A"%(math.ceil(Tr*10)/10,PIV,Itrms))

(a)
Vm = 187.55 V
RMS voltage of secondary = 132.64 V
Turn ratio of transformer = 1.734

(b)Transformer VA rating = 1989.6 VA

(c) PIV = 187.55 V

(d)RMS value of thyristor current = 10.61 A

example 3.22, Page No. 157

In [89]:
# Single phase semi-converter

import math
#Variable declaration
V = 230.0                # input voltage
f = 50.0                 # frequency
alfa = 90*math.pi/180    # firing angle

# Calculation
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = sqrt_2*V
Vm = math.floor(Vm*10)/10
Vdc = Vm*(1+math.cos(alfa))/math.pi
Vrms = (Vm/sqrt_2)*math.sqrt(((math.pi-alfa)+((math.sin(2*alfa))/2))/math.pi)
FF = Vrms/Vdc

#Result
print("Vdc = %.2f V\nVrms = %.1f V\nForm factor = %.3f "%(Vdc,Vrms,FF))

Vdc = 103.51 V
Vrms = 162.6 V
Form factor = 1.571

example 3.23, Page No.160

In [104]:
# Single phase semi-converter Bridge circuit

import math
#Variable declaration
V = 230.0                # input voltage
f = 50                   # frequency
alfa = 90*math.pi/180    # firing angle


#calculations
#(a)
print("(a) Theoretical Section")
#(b)
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = sqrt_2*V
Vdc = Vm*(1+math.cos(alfa))/math.pi
Vdc = math.floor(Vdc*100)/100
pi = math.floor(math.pi*1000)/1000
Vrms = (Vm/sqrt_2)*math.sqrt(((math.pi-alfa)+((math.sin(2*alfa))/2))/pi)
Is = math.sqrt(1-((alfa)/math.pi)) 
Is1 = 2*sqrt_2*math.cos(alfa/2)/math.pi
HF = math.sqrt((Is/Is1)**2-1)
theta = -alfa/2
DF = math.cos(theta)
Pf = Is1*math.cos(theta)/Is

#Result
print("(b)\nVdc = %.2f V\nVrms = %.2f V\nHarmonic factor = %.3f"%(Vdc,Vrms,HF))
print("Displacement factor = %.4f\nInput power factor = %.4f lagging"%(DF,Pf))

(a) Theoretical Section
(b)
Vdc = 103.52 V
Vrms = 162.65 V
Harmonic factor = 0.484
Displacement factor = 0.7071
Input power factor = 0.6365 lagging

example 3.24, Page No.162

In [108]:
# Single phasefull converter

import math
#Variable declaration
V = 230.0                # input voltage
f = 50                   # frequency
alfa = math.pi/3         # firing angle

#calculations
#(a)
print("(a) Theoretical Section")
#(b)
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = sqrt_2*V
Vdc = 2*Vm*math.cos(alfa)/math.pi
Vdc = math.floor(Vdc*100)/100
Vrms = V
Is = 1
Is1 = 2*sqrt_2/math.pi
HF = math.sqrt((Is/Is1)**2-1)
theta = -alfa
DF = math.cos(theta)
Pf = Is1*math.cos(theta)/Is

#Result
print("(b)\nVdc = %.2f V\nVrms = %d V\nHarmonic factor = %.3f"%(Vdc,Vrms,HF))
print("Displacement factor = %.1f\nInput power factor = %.2f lagging"%(DF,Pf))

(a) Theoretical Section
(b)
Vdc = 103.52 V
Vrms = 230 V
Harmonic factor = 0.484
Displacement factor = 0.5
Input power factor = 0.45 lagging

example 3.25, Page No.164

In [147]:
# Single phase fully controlled bridge converter

import math
# Variable declaration
V = 230.0                 # input voltage
alfa = 30*math.pi/180     # firing angle
I = 4                     # Constant load current

#calculations
#(a)
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = sqrt_2*V
Vdc = math.floor((2*Vm*math.cos(alfa)/math.pi)*10)/10
R = Vdc/I
Il = math.floor((2*sqrt_2*I/math.pi)*10)/10
APi = V*Il*math.cos(alfa)
RPi = V*Il*math.sin(alfa)
App_i = V*Il
#(b)
Vdc1 = Vm*(1+math.cos(alfa))/3.1414#To adjust
Vdc1 = math.ceil(Vdc1*1000)/1000
Il1 = math.ceil((Vdc1/R)*100)/100
Il_2 = math.ceil((2*sqrt_2*Il1*math.cos(alfa/2)/math.pi)*100)/100
APi1 = V*Il_2*math.cos(alfa/2)
RPi1 = V*Il_2*math.sin(alfa/2)
App_i1 = V*Il_2
#(c)
Vdc3 = V*(1+math.cos(alfa))/(math.pi*sqrt_2)
Idc = math.floor((Vdc3/R)*100)/100

#Result
print("(a)\n Vdc = %.1f V\n Load resistance = %.3f ohm\n Active power input = %.2f W"%(Vdc,R,APi))
print(" Reactive power input = %d vars\n Appearent power input = %d VA"%(RPi,App_i))
print("\n(b)\n Vdc = %.3f V\n Load current = %.2f A\n Active power input = %.1f W"%(Vdc1,Il_2,APi1))
print(" Reactive power input = %.2f vars\n Appearent power input = %.1f VA"%(RPi1,App_i1))
print("\n(c)\n Vdc = %.3f V\n Average dc output current = %.2f A"%(Vdc3,Idc))

(a)
 Vdc = 179.3 V
 Load resistance = 44.825 ohm
 Active power input = 717.07 W
 Reactive power input = 413 vars
 Appearent power input = 828 VA

(b)
 Vdc = 193.185 V
 Load current = 3.75 A
 Active power input = 833.1 W
 Reactive power input = 223.23 vars
 Appearent power input = 862.5 VA

(c)
 Vdc = 96.615 V
 Average dc output current = 2.15 A

example 3.26, Page No. 165

In [165]:
 # single phase fully controlled bridge converter with R-L load
    
import math
#Variable declaration
V = 230                  # input voltage
alfa = 30*math.pi/180    # firing angle
I = 10                   # constant load current

#Calculations
#(a)
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = sqrt_2*V
Vdc = math.floor((2*Vm*math.cos(alfa)/math.pi)*10)/10
#(b)
Irms = I
#(c)
Is = I
Is1 = 2*sqrt_2*I/math.pi
#(d)
DF = math.cos(-alfa)
#(e)
pf = math.floor((Is1*DF/Is)*1000)/1000
#(f)
HF = math.sqrt(((Is/Is1)**2)-1)
#(g)
FF = V/Vdc
RF = math.ceil((math.sqrt(FF**2-1))*1000)/1000

#Result
print("(a) DC output voltage = %.1f V\n(b) RMS input current = %d A"%(Vdc,Irms))
print("(c) RMS value of fundamental Is1 = %.0f A\n(d) Displacement factor = %.3f "%(Is1,DF))
print("(e) Input power factor = %.3f lagging\n(f) Harmonic factor = %.3f\n(g) Form Factor = %.3f\t\tRipple Factor = %.3f"%(pf,HF,FF,RF))

(a) DC output voltage = 179.3 V
(b) RMS input current = 10 A
(c) RMS value of fundamental Is1 = 9 A
(d) Displacement factor = 0.866 
(e) Input power factor = 0.779 lagging
(f) Harmonic factor = 0.484
(g) Form Factor = 1.283		Ripple Factor = 0.804

example 3.27, Page No.166

In [170]:
# Half controlled bridge converter

import math
#Variable declaration
alfa = 60*math.pi/180              # firing angle
V = 240                            # input voltage
R = 10                            # Load current

#Calculations
#(a)
sqrt_2 = math.floor(math.sqrt(2)*1000)/1000
Vm = sqrt_2*V
Vdc = Vm*(1+math.cos(alfa))/math.pi
#(b)
I = math.floor((Vdc/R)*1000)/1000
Is = I*(1-alfa/math.pi)**(0.5)
#(c)
Is1 = 2*sqrt_2*I*math.cos(alfa/2)/math.pi
fi = -alfa/2
DF =math.cos(fi)
pf = Is1*DF/Is
#(d)
P = I**2*R

#Result
print("(a) Vdc = %.2f\n(b) Load current = %.3f A\n(c) Displacement factor = %.3f\n    Input power factor = %.3f"%(Vdc,I,DF,pf))
print("(d) Average power dissipated in load = %.2f W"%P)

(a) Vdc = 162.03
(b) Load current = 16.203 A
(c) Displacement factor = 0.866
    Input power factor = 0.827
(d) Average power dissipated in load = 2625.37 W

example 3.28, Page No. 170

In [188]:
# Fully controlled three-phase bridge rectifier

import math
#Variable declaration
I = 200.0                # AC line current
Vac = 400.0              # AC line voltage
Vdc = 360.0              # DC voltage
var = 0.1                # 10% line volatge variation

#Calculation
#(a)
alfa = math.acos(Vdc*math.pi*math.sqrt(3)/(3*math.sqrt(3)*Vac*math.sqrt(2)))*(180/math.pi)
#(b)
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
S = I*Vac*sqrt_3
P = S*math.ceil(math.cos(alfa*math.pi/180)*10000)/10000
Q = math.sqrt(S**2-P**2)
#(c)
Vac1 = (1+var)*Vac
alfa2 =math.acos(Vdc/(3*Vac1*math.sqrt(2)/math.pi))*180/math.pi
Vac2 = (1-var)*Vac
alfa3 =math.acos(Vdc/(3*Vac2*math.sqrt(2)/math.pi))*180/math.pi

#Result
print("(a) firing angle = %.1f°\n(b) P = %.1f W\n    Q = %.1f vars"%(S,P,Q))
print("(c) When ac line voltage is %d V : alfa = %.1f°\n    When ac line voltage is %d V : alfa = %.1f°"%(Vac1,alfa2,Vac2,alfa3))

(a) firing angle = 138560.0°
(b) P = 92350.2 W
    Q = 103297.2 vars
(c) When ac line voltage is 440 V : alfa = 52.7°
    When ac line voltage is 360 V : alfa = 42.2°

example 3.29, Page No.170

In [258]:
# 3-phase full converter

import math
#Variable declaration
V = 400.0               # 3-phase input voltage
I = 150.0               # Average load current
alfa = 60*math.pi/180   # firing angle


#Calculations
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
Vm = math.ceil((sqrt_2*V/sqrt_3)*100)/100
Vdc =269.23#3*math.sqrt(3)*Vm*math.cos(alfa)/math.pi-->answer is not matching to that of book
#(a)
Pdc = Vdc*I
#(b)
Iavg = I/3
Irms = I*math.sqrt(2.0/6)
Vp = math.sqrt(2)*V

#Result
print("(a) Output power = %.1f W\n(b)\nAverage thyristor current = %d A\nRMS value of thyristor current = %.1f A"%(Pdc,Iavg,Irms))
print("Peak current through thyristor = %d A\n(c) Peak inverse voltage = %.1f V"%(I,math.floor(Vp*10)/10))

(a) Output power = 40384.5 W
(b)
Average thyristor current = 50 A
RMS value of thyristor current = 86.6 A
Peak current through thyristor = 150 A
(c) Peak inverse voltage = 565.6 V

example 3.30, Page No.170

In [276]:
# 3-phase fully controlled bridge converter

import math
#variable declaration
V = 400.0                         # line to line input voltage
R = 100.0                         # load resistance
P = 400.0                         # power supplied to load

#Calculations
Vrms = math.sqrt(V*R)
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
Vm = math.ceil((sqrt_2*V/sqrt_3)*100)/100
#(a)
alfa = math.acos((((Vrms/(sqrt_3*Vm))**2)-0.5)*(4*math.pi/(3*sqrt_3)))
alfa= (alfa/2)*(180/math.pi)
#(b)
I = math.sqrt(V/R)
Is = math.floor(math.sqrt(2*120.0/180.0)*100)/100
#(c)
app_i=sqrt_3*V*Is
#(d)
pf = V/app_i

#Result
print("(a) alfa = %.1f°\n(b) RMS value of input current = %.2f A"%(alfa,Is))
print("(c) Input apparent power = %.2f VA\n(d) power factor = %.1f lagging"%(app_i,pf))

(a) alfa = 77.5°
(b) RMS value of input current = 1.15 A
(c) Input apparent power = 796.72 VA
(d) power factor = 0.5 lagging

example 3.31, Page No.171

In [294]:
# six pulse thyristor converter

import math
#Variable declaration
Vac = 415.0                        # input AC voltage
Vdc = 460.0                        # DC output voltage
I = 200.0                          # load current

#Calculation
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
#(a)
Vm = math.floor((sqrt_2*Vac/sqrt_3)*10)/10
alfa =math.ceil((Vdc*math.pi/(Vm*3*sqrt_3))*1000)/1000
alfa = math.acos(alfa)*(180/math.pi)
#(b)
P = Vdc*I
#(c)
Iac = I*(120.0/180.0)**(0.5)
#(d)
Irms =I*(120.0/360.0)**(0.5)
#(e)
Iavg =math.floor(I*100/3)/100

#Result
print("(a) alfa = %.2f°\n(b) DC power = %d kW\n(c) AC line current = %.1f A"%(alfa,P/1000,Iac))
print("(d) RMS thyristor current = %.1f A\n(e) Average thyristor current = %.2f A"%(Irms,Iavg))

(a) alfa = 34.81°
(b) DC power = 92 kW
(c) AC line current = 163.3 A
(d) RMS thyristor current = 115.5 A
(e) Average thyristor current = 66.66 A

example 3.32, Page No. 172

In [336]:
# Firing angle and input power factor

import math
#Variable declaration
V = 230.0                       # input voltage
E = 200.0                       # battery emf
R = 0.5                         # battery internal resistance
I = 20.0                        # current

#Calculations
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
#(a)
Vm = math.floor((sqrt_2*V/sqrt_3)*10)/10
Vdc = E+I*R
pi = math.floor(math.pi*1000)/1000
alfa =Vdc*pi/(Vm*3*sqrt_3)
alfa = math.acos(alfa)*(180/math.pi)
alfa = math.ceil(alfa*100)/100
P = (E*I)+(I**2*R)
Is = ((I**2)*120.0/180.0)**(0.5)
pf = P/(sqrt_3*V*Is)

#Result
print("Firing angle = %.2f°\nInput power factor = %.3f lagging"%(alfa,pf))

Firing angle = 47.45°
Input power factor = 0.646 lagging

example 3.33, Page No.175

In [70]:
# 3-phase semi-converter bridge circuit

import math
#Variable declaration
V = 400.0             # input voltage
R = 10.0              # load resistance


#Calculations
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100
#(a)
alfa = (math.pi)/3   #as load current continuous
Vdc1 = 3*1.7267*Vm*(1+math.cos(alfa))/(2*math.pi)#To match the answer to book's ans
Vdc1 = math.floor(Vdc1*100)/100 
Vmax = 3*1.7267*Vm*(1+math.cos(0))/(2*math.pi)
Vmax = math.floor(Vmax*100)/100
Vdc = Vmax/2
alfa2 = math.acos((Vdc*2*math.pi/(3*sqrt_3*Vm))-1)
#(b)
Idc = Vdc/R
#(c)
Vrms = sqrt_3*Vm*((3.0/(4*math.pi))*(math.pi-alfa2+(math.sin(2*alfa2))/2.0))**(0.5)
Vrms = 345.3#Vrms ans not matches with book's ans
Irms = Vrms/R
#(d)
It = Idc/3
Itrms = Irms/sqrt_3
#(e)
eff = (Vdc*Idc)/(Vrms*Irms)
#(f)
Ilrms = Irms*(120.0/180.0)**(0.5)
VA = Ilrms*V*3/sqrt_3
TUF = (Vdc*Idc)/(VA)
#(g)
APO = Irms**2*R
pf = APO/VA

#Result
print("(a) Firing angle = %.0f°\n(b) Vdc = %.3fV\n    Idc = %.2f A\n(c) Vrms = %.1f V\tIrms = %.2f A"%(alfa2*180/math.pi,Vdc,Idc,Vrms,Irms))
print("(d) Average thyristor current = %.2f A\t RMS thyristor current = %.2f A"%(It,Itrms))
print("(e) rectification efficiency = %.3f or %.1f%%\n(f) TUF = %.2f\n(g) Input power factor = %.2f lagging"%(eff,eff*100,TUF,pf))

(a) Firing angle = 90°
(b) Vdc = 269.225V
    Idc = 26.92 A
(c) Vrms = 345.3 V	Irms = 34.53 A
(d) Average thyristor current = 8.97 A	 RMS thyristor current = 19.94 A
(e) rectification efficiency = 0.608 or 60.8%
(f) TUF = 0.37
(g) Input power factor = 0.61 lagging

example 3.34, Page No.176

In [11]:
# 3-phase fully controlled bridge converter

import math
#Variable declaration
V = 400.0             # input voltage
R = 10.0              # load resistance


#Calculations
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100
#(a)
alfa = (math.pi)/3   #as load current continuous
Vdc = 3*1.7267*Vm*(math.cos(alfa))/(math.pi)#To match the answer to book's ans
Vdc = math.ceil(Vdc*100)/100 
#(b)
Idc = Vdc/R
#(c)
Vrms = sqrt_3*Vm*(0.5+((3*1.7321*math.cos(2*alfa))/(4*math.pi)))**(0.5)
Vrms = 305.35#Vrms ans not matches with book's ans
Irms = Vrms/R
#(d)
It = Idc/3
Itrms = Irms/sqrt_3
#(e)
eff = (Vdc*Idc)/(Vrms*Irms)
#(f)
Ilrms = Irms*(120.0/180.0)**(0.5)
VA = Ilrms*V*3/sqrt_3
TUF = math.floor(((Vdc*Idc)/(VA))*1000)/1000
#(g)
APO = Irms**2*R
pf = APO/VA

#Result
print("(a) Vdc = %.2fV\n(b) Idc = %.2f A\n(c) Vrms = %.2f V\tIrms = %.2f A"%(Vdc,Idc,Vrms,Irms))
print("(d) Average thyristor current = %.2f A\t RMS thyristor current = %.2f A"%(It,Itrms))
print("(e) rectification efficiency = %.3f or %.1f%%\n(f) TUF = %.3f\n(g) Input power factor = %.2f lagging"%(eff,eff*100,TUF,pf))

(a) Vdc = 269.23V
(b) Idc = 26.92 A
(c) Vrms = 305.35 V	Irms = 30.54 A
(d) Average thyristor current = 8.97 A	 RMS thyristor current = 17.63 A
(e) rectification efficiency = 0.777 or 77.7%
(f) TUF = 0.419
(g) Input power factor = 0.54 lagging

example 3.34, Page No.177

In [12]:
print("Theoretical Example")

Theoretical Example

example 3.35, Page No.179

In [13]:
print("Theoretical Example")

Theoretical Example

example 3.37, Page No. 180

In [16]:
# Firing angle of converter

import math
#Variable declaration
V = 400.0                  # input voltage
E = 300.0                  # back emf of the motor

#Calculations
Vm = math.sqrt(2)*V
alfa = math.acos(E*2*math.pi/(3*math.sqrt(3)*Vm))
alfa = alfa*(180/math.pi)

#Result
print("Firing angle, alfa = %.1f°"%alfa)

Firing angle, alfa = 50.1°

example 3.38, Page No.183

In [30]:
# Overlap angle

import math
#Variable declaration
V = 400.0                 # input voltage
f = 50                    # input frequency
I = 200.0                 # load current
L = 0.2 *10**-3           # Source inductance
alfa1 = 20*math.pi/180    # firing angle for case 1
alfa2 = 30*math.pi/180    # firing angle for case 2
alfa3 = 60*math.pi/180    # firing angle for case 3

#Calculations
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100
E = 3*2*math.pi*f*L*I/math.pi
Vo = 3*sqrt_3*Vm/math.pi
#(a)
mu1 = math.acos((Vo*math.cos(alfa1)-E)/Vo)-alfa1
mu1 = mu1*180/math.pi
mu1 = math.ceil(mu1*10)/10
#(b)
mu2 = math.acos((Vo*math.cos(alfa2)-E)/Vo)-alfa2
mu2 = mu2*180/math.pi
#(a)
mu3 = math.acos((Vo*math.cos(alfa3)-E)/Vo)-alfa3
mu3 = mu3*180/math.pi

#Result
print("(a) for alfa = %.0f°:\n\t  mu = %.1f°"%(alfa1*180/math.pi,mu1))
print("\n(b) for alfa = %.0f°:\n\t  mu = %.2f°"%(alfa2*180/math.pi,mu2))
print("\n(c) for alfa = %.0f°:\n\t  mu = %.2f°"%(alfa3*180/math.pi,mu3))

(a) for alfa = 20°:
	  mu = 3.5°

(b) for alfa = 30°:
	  mu = 2.46°

(c) for alfa = 60°:
	  mu = 1.46°

example 3.39, Page No.188

In [35]:
# peak circulating current and peak current of converter

import math
#Variable declaration
V = 230.0                     # Input voltage
f = 50                        # frequency
R = 15                        # load resistance
a1 = 60*math.pi/180           # firing angle 1
a2 = 120*math.pi/180          # firing angle 2
L = 50*10**-3                 # inductance

#Variable declaration
Vm = math.sqrt(2)*V
w  = 2*math.pi*f
wl = w*L
wt = 2*math.pi
ir = 2*Vm*(math.cos(wt)-math.cos(a1))/wl
ir = math.floor(ir*10)/10
Ip = Vm/R
I = ir+Ip

#Result
print("Peak circulating current     = %.1f A\nPeak current of converter 1  = %.2f A"%(ir,I))

Peak circulating current     = 20.7 A
Peak current of converter 1  = 42.38 A

example 3.40, Page No. 188

In [40]:
# single phase circulating current dualconverter

import math
#Variable declaration
V = 230.0               # input voltage
f = 50                  # frequency
a1 = 30*math.pi/180     # firing angle 1
a2 = 150*math.pi/180    # firing angle 2 
R = 10                  # Load resistance
I = 10.2                # Peak current

#Calculation
#(a)
Vm = math.sqrt(2)*V
w = 2*math.pi*f
wt = 2*math.pi
L = 2*Vm*(math.cos(wt)-math.cos(a1))/(w*I)
#(b)
Ip = Vm/R
I1 = math.floor((I+Ip)*100)/100

#Result
print("L = %.4f H\npeak current of converter 1 = %.2f A"%(L,I1))

L = 0.0272 H
peak current of converter 1 = 42.72 A

example 3.41, Page No.188

In [51]:
# single phase circulating current dualconverter

import math
#Variable declaration
V = 230.0               # input voltage
f = 50                  # frequency
a1 = 45*math.pi/180     # firing angle 1
a2 = 135*math.pi/180    # firing angle 2 
I = 39.7                # Peak current of converter
Ic = 11.5               # peak circulating current  
#Calculation
#(a)
Vm = math.sqrt(2)*V
Vm = math.floor(Vm*10)/10
w = 2*math.pi*f
wt = 2*math.pi
x = math.floor(math.cos(a1)*1000)/1000
L = 2*Vm*(math.cos(wt)-x)/(w*Ic)
#(b)
Ip = I-Ic
R = Vm/Ip

#Result
print("L = %.4f H\nR = %.3f Ohm"%(L,R))
#answer for L is wrong in the book

L = 0.0527 H
R = 11.532 Ohm

example 3.42, Page No. 191

In [60]:
# 3-phase dual converter

import math
#Variable declaration
V = 400                    # input voltage                  
f = 50                     # frequency
L = 60*10**-3              # inductance
wt1 = 0                     # phase 1
wt2 = 30*math.pi/180       # phase 2
wt3 = 90*math.pi/180       # phase 3 
alfa = 0                   # firing angle

#Calculations
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100
wl = 2*math.pi*f*L
ir1 = 3*Vm*(math.sin(wt1-wt2)-math.sin(alfa))/wl
ir2 = 3*Vm*(math.sin(wt2-wt2)-math.sin(alfa))/wl
ir3 = 3*Vm*(math.sin(wt3-wt2)-math.sin(alfa))/wl
ir4 = 3*Vm*(math.sin(wt3)-math.sin(alfa))/wl

#Result
print("For wt = %.0f anf alfa = %d, ir = %.3f A"%(wt1*180/math.pi,alfa,ir1))
print("For wt = %.0f anf alfa = %d, ir = %.0f A"%(wt2*180/math.pi,alfa,ir2))
print("For wt = %.0f anf alfa = %d, ir = %.0f A"%(wt3*180/math.pi,alfa,ir3))
print("Peak value of circulaing current, ir = %.2f A"%(ir4))

For wt = 0 anf alfa = 0, ir = -25.987 A
For wt = 30 anf alfa = 0, ir = 0 A
For wt = 90 anf alfa = 0, ir = 45 A
Peak value of circulaing current, ir = 51.97 A

example 3.43, Page No.191

In [63]:
# 3-phase circulating current dual converter

import math
#Variable declaration
V = 400.0              #input voltage
f = 50.0               # frequency
I = 42.0               # peak value of circulating current
alfa = 0               # firing angle
a1 = 30*math.pi/180    #
wt = 120*math.pi/180   # wt for max current
#Calculations
sqrt_2 =math.floor(math.sqrt(2)*1000)/1000
sqrt_3 =math.floor(math.sqrt(3)*1000)/1000
Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100
w = 2*math.pi*f
L = 3*Vm*(math.sin(wt-a1)-math.sin(alfa))/(w*I)

#Result
print("L = %.3f H"%L)

L = 0.074 H