Chapter 10: Performance of Transmission Lines

Example 10.1, Page Number: 233

In [3]:
from __future__ import division
import math

#Variable declaration:
pf = 0.8                              #power factor
Z = 10+15j                           #load impedance(ohm)
magVr = 33000                            #receiving end voltage(V)
P = 1100                             #poweer delivered(kW)

#Calculation:
magI = P*1000/(magVr*pf)                    #line current(A)
phy = math.acos(pf)
Vr = magVr+0j                              #V
I = magI*(math.cos(phy)-math.sin(phy)*1j)    #A
Vs = Vr + I*Z

#Angle between Vs and Vr is
alpha = math.atan(Vs.imag/Vs.real)
phys = phy+alpha
pfs = math.cos(phys)
Pl = magI**2*Z.real/1000
Pi = P+Pl
n = P/Pi*100


#Result:
print "(i)  Sending end voltage is",round(abs(Vs)),"V"
print "(ii) sending end power factor is",round(pfs,4),"lagging"
print "(iii)Transmission efficiency is",round(n,2),"%"

(i)  Sending end voltage is 33709.0 V
(ii) sending end power factor is 0.7955 lagging
(iii)Transmission efficiency is 98.45 %

Example 10.2, Page Number: 235

In [4]:
from __future__ import division
import math

#Variable Declaration:
a = 0.775                      #cross-section of conductor(cm**2)
n = 0.9                               #transmission efficiency
Pr = 200000                    #receiving end power(W)
pf = 1                         #power factor
V = 3300                       #line voltage(V)
ro = 1.725                     #specific resistance(micro_ohm-cm)


#Calculation:
Ps = Pr/n                     #sending end power(W)
Pl = Ps-Pr                    #line loss(W)
I = Pr/(V*pf)                 #line current(A)
R = Pl/(2*I**2)                #resistance of 1 conductor(ohm)
l = R*a/(ro*10**-6)                     #length of conductor(cm)


#Result:
print "The conductor length is",round(l*10**-5,1),"km"

The conductor length is 13.6 km

Example 10.3, Page Number: 235

In [1]:
from __future__ import division
import math

#Variable Declaration:
pf = 0.8                        #power factor
Pr = 5000                       #receiving end power(kW)
Vr = 22                          #receiving end voltage(kV)
Z = 4+6j                        #impedance of each conductor(ohm)

#Calculation:
phy = math.acos(pf)
magVrp = Vr*1000/3**0.5                 #sending end voltage/phase(kV)
magI = Pr*1000/(3*magVrp*0.8)        #Line current(A)
Vr = magVrp+1j 
I = magI*(math.cos(phy)-math.sin(phy)*1j)

#(i)Sending end voltage per phase:
Vs = magVrp+I*Z
Vsl = abs(Vs)*3**0.5                #V

#(ii)
reg = (abs(Vs)-magVrp)/magVrp*100        #voltage regulation(%)
#(iii)
Pl = 3*abs(I)**2*Z.real/1000                  #line loss(kW)
n = Pr/(Pr+Pl)*100                  #transmission efficiency(%)

#Result:
print "(i) Sending end voltage is",round(abs(Vsl)/1000,3),"kV"
print "(ii)Percentage regulation is",round(reg,3),"%"
print "(iii)Transmission efficiency",round(n,2),"%"

(i) Sending end voltage is 23.942 kV
(ii)Percentage regulation is 8.825 %
(iii)Transmission efficiency 93.93 %

Example 10.4, Page Number: 236

In [6]:
from __future__ import division


#Variable declaration:
Pr = 15000                 #power delivered(kW)
Vl = 132                   #line voltage(kV)
Ro = 1                       #line resistance(ohm/km)
pf = 0.8                   #power factor

#Calculation:
I = Pr/(3**0.5*Vl*pf)      #line current(A)
#the loss in the transmission is to be 5%.
Pl = 5*Pr/100                  #kW
R = Pl*1000/(3*I**2)        #line resistance(ohm)
d = R/Ro                    #line length(km)

#Result:
print "Length of line is",round(d,2),"km"

Length of line is 37.17 km

Example 10.5, Page Number: 236

In [2]:
from __future__ import division
from sympy import *
import math

#Variable Declaration:
pf = 0.8                        #power factor
Pr = 3600                       #sending end power(kW)
magVs = 33                          #receiving end voltage(kV)
Z = 5.31+5.54j                        #impedance of each conductor(ohm)


#Calculation:
R = Z.real                      #ohm
X = Z.imag                      #ohm
phy = math.acos(0.8)
magVsp = magVs*1000/(3**0.5)     #V/phase
magVr = symbols('magVr')            #Receiving end voltage(V/phase)
magI = Pr*1000/(3*magVr*pf)            #line current(A)

#(i)Using approximate expression for magVsp,
magVr1 = solve((magVr+magI*R*pf+magI*X*math.sin(phy))-magVsp,magVr)[1]

#(ii)line current:
magI1 = Pr*1000/(3*magVr1*pf) 

#(iii)Efficiency
Pl = 3*magI1**2*R/1000                   #kW
n = Pr/(Pr+Pl)*100


#Result:
print "(i)  The receiving end voltage ",round(magVr1*3**0.5/1000,2),"V"
print "(ii) Line current is",round(magI1,2),"A"
print "(iii)Transmission efficiency is",round(n,2),"%"

(i)  The receiving end voltage  31.93 V
(ii) Line current is 81.36 A
(iii)Transmission efficiency is 97.15 %

Example 10.6, Page Number: 237

In [3]:
from __future__ import division
from sympy import *
import math

#Variable declaration:
Z = 6+8j                  #line impedance(ohm)
magVs = 120               #sending end voltages(kV)
magVr = 110                #receiving end voltaes(kV)
pf = 0.9                  #power factor


#Calculation:
R = Z.real                    #ohm
X = Z.imag                    #ohm
magVsp = round(120*1000/3**0.5)         #V/phase
magVrp = round(110*1000/3**0.5)         #V/phase
phy = math.acos(pf)
magI = symbols('magI')        #line current(A)
magI1 = solve(magVrp+magI*R*math.cos(phy)+magI*X*math.sin(phy)-magVsp,magI)[0]

#(i):
Po = 3*magVrp*round(magI1)*math.cos(phy)/1000       #kW

#(ii):
pfs = (magVrp*math.cos(phy)+magI1*R)/magVsp


#Result:
print "(i) Power output is",round(Po),"kW"
print "(ii)Sending end power factor",round(pfs,2),"lagging"

(i) Power output is 111458.0 kW
(ii)Sending end power factor 0.88 lagging

Example 10.7, Page Number: 237

In [10]:
from __future__ import division
import math

#Variable Declaration:
Z = 1.5+4j                     #impedance of the line(ohm)
magVr = 11000                  #receivig end voltage(V)
pf = 0.8                       #power factor
Pr = 5000                      #power delivered()


#Calculation:
R = Z.real                    #ohm
X = Z.imag                    #ohm
magVrp = magVr/3**0.5           #V/phase
phy = math.acos(pf)
magI = Pr*1000/(3*magVrp)       #line current(A)
magVsp = magVrp+magI*R*pf+magI*X*math.sin(phy)    #Volt
reg = (magVsp - magVrp)/magVrp*100             #voltage regulation(%)
Pl = 3*magI**2*R/1000           #line losses(kW)
Po = Pr*pf                      #output power(W)
Pi = Po + Pl                    #Input Power(kW)
n = Po/Pi*100                       #efficiency(%)


#Result:
print "The % regulation is",round(reg,2),"%"
print "The efficiency is",round(n,1),"%"

The % regulation is 14.88 %
The efficiency is 92.8 %

Example 10.8, Page Number: 238

In [11]:
from __future__ import division
import math

#Variable declaration:
Pr = 1000                    #power delivered(kW)
pf = 0.8                     #power factor
r = 0.03                     #line resistance per phase(ohm/km)
L = 0.7                     #line inductance per phase(mH)
l = 16                       #line length(km)
magVr = 11000                 #receiving line voltage(V)
f = 50                       #power frequency(Hz)

#Calculation:
R = r*l                      #line resistance(ohm)
X = 2*3.14*f*L/1000*l          #line reactance(ohm)
magVrp = round(magVr/3**0.5)       #receiving end (v/phase)
phy = math.acos(pf)
magI = round(Pr*1000/(3*magVrp*math.cos(phy)),1) #line current(A)
magVsp = magVrp+magI*R*math.cos(phy)+magI*X*math.sin(phy)
reg = (magVsp-magVrp)/magVrp*100        #Volt
Pl = round(3*magI**2*R/1000,1)           #line losses(kW)
Pi = Pr + Pl                    #Input Power(kW)
n = Pr/Pi*100                       #efficiency(%)


#Result:
print "The % regulation is",round(reg,2),"%"
print "The efficiency is",round(n,2),"%"

The % regulation is 2.58 %
The efficiency is 99.38 %

Example 10.9, Page Number: 238

In [12]:
from __future__ import division
import math


#Variable Declaration:
Pr = 2000                         #load power(kVA)
pf = 0.8                          #power factor
l = 20                            #line length(km)
r1 = 7.5;      x1 = 13.2  #resistance & reactance of transformer primary(ohm)
r2 = 0.35;      x2 = 0.65  #resistance & reactance of transformer secondary(ohm)
r = 0.4;       x = 0.5     ##resistance & reactance of line(ohm/km)
Vp = 33*1000                        #voltage at primary side(kV)
Vs = 6.6*1000                       #voltage at secondary side(kV)



#Calculation:
R = l*r                       #resistance of each conuctor(ohm)
X = l*x                       #reactance of each conductor(ohm)
phy = math.acos(pf)
#Let us transfer the impedance of transformer secondary
#to high tension side i.e., 33 kV side.
#Equivalent resistance of transformer referred to 33 kV side:
R1 = r1 + r2*(Vp/Vs)**2         #ohm

#Equivalent resistance of transformer referred to 33 kV side:
X1 = x1+ x2*(Vp/Vs)**2          #ohm


Rt = R+R1                    #Total resistance of line and transformer(ohm)
Xt = X+X1                    #Total reactance of line and transformer(omh)
Vr = Vp/3**0.5               #receiving end voltage(V/phase)
I = round(Pr*1000/(3**0.5*Vp))      #line current(A)
Vs = Vr+I*Rt*math.cos(phy)+I*Xt*math.sin(phy)      #sending end voltage(V)
Vsl = 3**0.5*Vs                 #sending end line voltage(V)
pfs = (Vr*pf+I*Rt)/Vs           #sending end power factor
Pl = 3*I**2*Rt/1000             #line loss(kW)
Po = Pr*pf                  #output power(kW)
n = Po/(Po+Pl)*100           #transmission efficiency(%)

#Result:
print "Sending end line voltage is",round(Vsl/1000,1),"V"
print "Sending end power factor is",round(pfs,4)
print "Transmission efficiency is",round(n,2),"%"

Sending end line voltage is 35.6 V
Sending end power factor is 0.7826
Transmission efficiency is 94.72 %

Example 10.10, Page Number: 241

In [2]:
from __future__ import division
import math

#Variable declaration:
r = 0.25                        #resistance of line(ohm/km)
l = 100                         #line length(km)
x = 0.8                         #Reactance(ohm/km)
y = 14*10**-6                   #susceptance(siemen/km)
magVr = 66000                   #Receiving end line voltage(V)
Pr = 15000                      #power delivered(kW)
pf = 0.8                        #power factor(lagging)



#Calculation:
R = r*l                        #ohm
X = x*l                        #ohm
Y = y*l                        #siemen
magI = Pr*1000/(pf*magVr)           #line current(A)
phy = math.acos(pf)             #phasor angle
Vr = magVr+0j                   #Volt
Ir = round(magI*pf)-round(magI*math.sin(phy))*1j   #load current(A)
Ic = 1j*round(Y*magVr)

#(i):
Is = Ir+Ic                      #Sending end current(A)

#(ii):
delV = Is*(R+X*1j)              #voltage rop(V)
Vs = Vr+delV                    #sending end voltage(V)
reg = (abs(Vs)-magVr)/magVr*100         #voltage regulation(%)

#phase angle between Vr & Ir:
theta1 = math.atan(Is.imag/Is.real)

#phase angle between Vr & Is:
theta2 = math.atan(Vs.imag/Vs.real)

phys = abs(theta1)+theta2
pfs = math.cos(phys)            #supply power factor


#Result:
print "(i)  The sending end current is",round(abs(Is)),"A"
print "(ii) The sending end voltage is",round(abs(Vs)),"V"
print "(iii)Regulation is",round(reg,2),"%"
print "(iv) Supply power factor is",round(pfs,2),"lagging"

(i)  The sending end current is 240.0 A
(ii) The sending end voltage is 79583.0 V
(iii)Regulation is 20.58 %
(iv) Supply power factor is 0.86 lagging

Example 10.11, Page Number: 244

In [14]:
from __future__ import division
import math

#Variable declaration:
l = 100                       #line length(km)
r = 0.1                       #resistance/km/phase(ohm)
xl = 0.2                      #reactance/km/phase(ohm)
b = 0.04*10**-4                #Capacitive susceptance/km/phase(siemen)
Pr = 10000                    #power delivered(kW)
Vrl = 66000                     #sending end line volt(V)
pf = 0.8                      #power factor(lagging)


#Calculation:
R = r*l                        #Total resistance/phase(ohm)
Xl = xl*l                       #Total reactance/phase(ohm)
Y = b*l                        #Capacitive susceptance(siemen)
magVr = round(Vrl/3**0.5)              #Receiving end voltage/phase(V)
magIr = round(Pr*1000/(3**0.5*Vrl*pf))   #Load current(A)
phy = math.acos(pf)
Z = R+Xl*1j                     #Impedance per phase(ohm)
#(i) Taking receiving end voltage as the reference phasor,
Vr = magVr+0j
Ir = magIr*(pf-math.sin(phy)*1j)      #A
V1 = Vr+Ir*Z/2                 #Voltage across C(V)
Ic = 1j*Y*V1                  #Charging current(A)
Is = Ir+Ic                    #sending end current(A)


#(ii) Sending end voltage,
Vs = V1+Is*Z/2                 #V
magVsl = 3**0.5*abs(Vs)         #Line value of sending end voltage(V)

#(iii) Referring to phasor diagram (iii),
theta1 = math.atan(Vs.imag/Vs.real)     #angle between Vr & Vs
theta2 = math.atan(abs(Is.imag/Is.real)) #angle between Vr & Is
phys = theta1+theta2                    #angle b/w Vs & Is

pfs = math.cos(phys)                    #Sending end power factor

#(iii):
Ps = 3*abs(Vs)*abs(Is)*pfs/1000             #Sending end power(kW)
n = Pr/Ps*100                          #Efficiency(%)


#Result:
print "(i)  The sending end current is",round(abs(Is)),"A"
print "(ii) Sending end voltage is",round(magVsl/1000,3),"kV"
print "(iii)Sending end power factor is",round(pfs,3),"lagging"
print "(iv) Transmission efficiency is",round(n,2),"%"

(i)  The sending end current is 100.0 A
(ii) Sending end voltage is 69.532 kV
(iii)Sending end power factor is 0.853 lagging
(iv) Transmission efficiency is 97.12 %

Example 10.12, Page Number: 245

In [15]:
from __future__ import division
import math


#Variable declaration:
l = 100                       #line length(km)
r = 0.2                       #resistance/km/phase(ohm)
xl = 0.4                      #reactance/km/phase(ohm)
b = 2.5*10**-6                #Capacitive susceptance/km/phase(siemen)
Pr = 20000                    #power delivered(kW)
Vrl = 110000                     #sending end line volt(V)
pf = 0.9                      #power factor


#Calculation:
R = r*l                        #Total resistance/phase(ohm)
Xl = xl*l                       #Total reactance/phase(ohm)
Y = b*l                        #Capacitive susceptance(siemen)
magVr = round(Vrl/3**0.5)              #Receiving end voltage/phase(V)
magIr = round(Pr*1000/(3**0.5*Vrl*pf))   #Load current(A)
phy = math.acos(pf)
Z = R+Xl*1j                     #Impedance per phase(ohm)

#(i) Taking receiving end voltage as the reference phasor,
Vr = magVr+0j
Ir = magIr*(pf-(math.sin(phy))*1j)      #A
V1 = Vr+Ir*Z/2                 #Voltage across C(V)
Ic = 1j*Y*V1                  #Charging current(A)
Is = Ir+Ic                    #sending end current(A)
Vs = V1+Is*Z/2                 #V
magVsl = 3**0.5*abs(Vs)         #Line value of sending end voltage(V)

#(ii):
Pl = 3*abs(Is)**2*R/2+3*magIr**2*R/2      #line loss(W)
n = Pr/(Pr+Pl/1000)*100           #efficiency


#Result:
print "(i) The current and voltage at the sending end is",round(magVsl/1000,2),"kV"
print "(ii)Efficiency of transmission is",round(n,2),"%"

(i) The current and voltage at the sending end is 116.75 kV
(ii)Efficiency of transmission is 96.26 %

Example 10.13, Page Number: 247

In [16]:
from __future__ import division
import math

#Variable Declaration:
l = 150                      #line length(km)
r = 0.1                       #resistance/km/phase(ohm)
xl = 0.5                      #reactance/km/phase(ohm)
b = 3*10**-6                #Capacitive susceptance/km/phase(siemen)
Pr = 50000                    #power delivered(kW)
Vrl = 110000                     #sending end line volt(V)
pf = 0.8                      #power factor


#Calculation:
R = r*l                        #Total resistance/phase(ohm)
Xl = xl*l                       #Total reactance/phase(ohm)
Y = b*l                        #Capacitive susceptance(siemen)
magVr = round(Vrl/3**0.5)              #Receiving end voltage/phase(V)
magIr = round(Pr*1000/(3**0.5*Vrl*pf))   #Load current(A)
phy = math.acos(pf)
Z = R+Xl*1j                     #Impedance per phase(ohm)

Vr = magVr+0j
Ir = magIr*(pf-(math.sin(phy))*1j)      #A
Ic1 = Vr*1j*Y/2                         #Charging current at the load end(A)
Il = Ir+Ic1                       #line current(A)
Vs = Vr+Il*Z                      #Sending end voltage(V)
magVsl = abs(Vs)*3**0.5           #Line to line sending end voltage(V)
Ic2 = 1j*Vs*Y/2                    #Charging current at the sending end(A)
Is = Il+Ic2                      #Sending end current(A)


#Result:
print "The sending end voltage is",round(magVsl/1000,2),"V"
print "The sending end current is",round(abs(Is),1),"A"

The sending end voltage is 143.56 V
The sending end current is 306.3 A

Example 10.14, Page Number: 248

In [17]:
from __future__ import division
import math


#Variable Declaration:
l = 100                      #line length(km)
r = 0.1                       #resistance/km/phase(ohm)
xl = 0.5                      #reactance/km/phase(ohm)
b = 10*10**-6                #Capacitive susceptance/km/phase(siemen)
Pr = 20000                    #power delivered(kW)
Vrl = 66000                     #sending end line volt(V)
pf = 0.9                      #power factor


#Calculation:
R = r*l                        #Total resistance/phase(ohm)
Xl = xl*l                       #Total reactance/phase(ohm)
Y = b*l                        #Capacitive susceptance(siemen)
magVr = round(Vrl/3**0.5)              #Receiving end voltage/phase(V)
magIr = round(Pr*1000/(3**0.5*Vrl*pf))   #Load current(A)
phy = math.acos(pf)
Z = R+Xl*1j                     #Impedance per phase(ohm)

Vr = magVr+0j
Ir = magIr*(pf-(math.sin(phy))*1j)      #A
Ic1 = round(magVr*Y/2)*1j                         #Charging current at the load end(A)
Il = Ir+Ic1                       #line current(A)
Vs = Vr+Il*Z                      #Sending end voltage(V)
magVsl = abs(Vs)*3**0.5           #Line to line sending end voltage(V)
Ic2 = 1j*Vs*Y/2                    #Charging current at the sending end(A)
Is = Il+Ic2                      #Sending end current(A)

#(i):
theta1 = math.atan(Vs.imag/Vs.real)     #angle between Vr & Vs
theta2 = math.atan(abs(Is.imag/Is.real)) #angle between Vr & Is
phys = theta1+theta2                    #angle b/w Vs & Is
pfs = math.cos(phys)                    #Sending end power factor

#(ii):
reg = (abs(Vs)-magVr)/magVr*100            #voltage regulation(%)

#(iii):
Ps = 3*abs(Vs)*abs(Is)*pfs/1000         #sending end power(W)
n = Pr/Ps*100                          #transmission efficiency(%)


#Result:
print "(i)  Sending end power factor is",round(pfs,3),"lagging"
print "(ii) Regulation is",round(reg,2),"%"
print "(iii)Transmission efficiency is",round(n),"%"

(i)  Sending end power factor is 0.906 lagging
(ii) Regulation is 15.15 %
(iii)Transmission efficiency is 95.0 %

Example 10.15, Page Number: 254

In [18]:
import cmath

#Variable Declaration:
l = 200                      #line length(km)
r = 0.16                       #resistance/km/phase(ohm)
xl = 0.25                      #reactance/km/phase(ohm)
b = 1.5*10**-6*1j                #Capacitive susceptance/km/phase(siemen)
Pr = 20000                    #power delivered(kW)
Vrl = 110000                     #sending end line volt(V)
pf = 0.8                      #power factor

#Calculation:
R = r*l                        #Total resistance/phase(ohm)
Xl = xl*l                       #Total reactance/phase(ohm)
Y = b*l                        #Capacitive susceptance(siemen)
Z = R+Xl*1j                    #Series Impedance/phase(ohm)
magVr = Vrl/3**0.5            #Receiving end voltage per phase(V)
magIr = round(Pr*1000/(3**0.5*Vrl*pf))           #Receiving end current(A)
Vs = magVr*cmath.cosh((Y*Z)**0.5)+magIr*(Z/Y)**0.5*cmath.sinh((Z*Y)**0.5) #sending end voltage(V/phase)
Is = magVr*(Y/Z)**0.5*cmath.sinh((Y*Z)**0.5)+magIr*cmath.cosh((Y*Z)**0.5)


#Result:
print "Sending end line-to-line voltage is",round(3**0.5*abs(Vs)/1000,1),"V"
print "Sending end current is",round(abs(Is),1),"A"

Sending end line-to-line voltage is 117.0 V
Sending end current is 131.5 A

Example 10.16, Page Number: 258

In [4]:
from __future__ import division
import cmath
import math

#Variable Declaration:
Z = 20+52j                    #Series line impedance/phase(ohm)
Y = 315*10**-6*1j             #Shunt admittance/phase(siemen)
pf = 0.85                      #power factor
Pr = 30000                    #receiving end power(kW)
magVrl = 132000                    #receiving end voltage(V)


#Calculation:
#(i) Generalised constants of line,
A = 1+Z*Y/2
D = A
B = Z*(1+Z*Y/4)
C = Y

#(ii) Sending end voltage,
magVr = magVrl/3**0.5          #V/phase
magIr = Pr*1000/(3**0.5*magVrl*pf)        #line current(A)
phy = math.acos(pf)
Vr = magVr+0j
Ir = magIr*(math.cos(phy)-1j*math.sin(phy))
Vs = A*Vr+B*Ir
magVs = abs(Vs)                #sending end voltage(V/phase)
magVsl = 3**0.5*magVs          #Sending end line-to-line voltage(V)


#(iii) Regulation:
#At no load, Ir = 0,
magVro = abs(Vs/A)
reg = (magVro-magVr)/magVr*100           #regulation(%)


#Result:
print "(i)The A, B, C and D constants of the line are"
print "   A =",complex(round(A.real,3),round(A.imag,5))
print "   B =",complex(round(B.real,2),round(B.imag,2))
print "   C =",complex(round(C.real,6),round(C.imag,6))
print "   D =",complex(round(D.real,3),round(D.imag,5))

print "(ii) Sending end voltage is",round(magVs*3**0.5/1000),"kV"
print "(iii)Regulation of the line is",round(reg,2),"%"

(i)The A, B, C and D constants of the line are
   A = (0.992+0.00315j)
   B = (19.84+51.82j)
   C = 0.000315j
   D = (0.992+0.00315j)
(ii) Sending end voltage is 143.0 kV
(iii)Regulation of the line is 9.25 %

Example 10.17, Page Number: 259

In [5]:
from __future__ import division
import cmath
import math

#Variable Declaration:
A = cmath.rect(0.95,math.radians(1.4))
B = cmath.rect(96,math.radians(78))
C = cmath.rect(0.0015,math.radians(90))
D = cmath.rect(0.95,math.radians(1.4))
Pr = 50000                         #receiving end power(kW)
pf = 0.8                            #power factor
magVrl = 132000                     #receiving end voltage(V)


#Calculation:
magVr = magVrl/3**0.5                #Receiving end voltage/phase(V)
magIr = Pr*1000/(3**0.5*magVrl*pf)        #line current(A)
phy = math.acos(pf)
Vr = magVr+0j
Ir = magIr*(math.cos(phy)-1j*math.sin(phy))
Vs = A*Vr+B*Ir                    #Sending end voltage per phase
Is = C*Vr+D*Ir                    #Sending end current
Ic = Is-Ir                       #Charging current
#At no load, Ir = 0,
magVro = abs(Vs/A)
reg = (magVro-magVr)/magVr*100           #regulation(%)


#Result:
print "Charging current is  (",round(abs(Ic)),round(math.degrees(angle(Ic)),1),")  A"
print "Regulation is",round(reg),"%"

Charging current is  ( 128.0 93.2 )  A
Regulation is 30.0 %

Example 10.18, Page Number: 260

In [6]:
from __future__ import division
import cmath
import math

#Variable Declaration:
A = cmath.rect(0.98,math.radians(3))
B = cmath.rect(110,math.radians(75))
C = cmath.rect(0.0005,math.radians(80))
D = cmath.rect(0.98,math.radians(3))
MVA = 50                         #receiving end power
pf = 0.8                            #power factor
magVrl = 110                     #receiving end voltage(kV)


#Calculation:
Pr = MVA*pf*10**6
magVr = round(magVrl/3**0.5,1)                #Receiving end voltage/phase(V)
magIr = round(MVA*10**6/(3**0.5*magVrl*1000),1)        #line current(A)
phy = math.acos(pf)
Vr = magVr*1000+0j
Ir = magIr*(math.cos(phy)-1j*math.sin(phy))
#(round(Ir.real)+1j*round(Ir.imag))
V1 = round((A*Vr).real)+math.ceil((A*Vr).imag)*1j
V2 = round((B*Ir).real)+math.ceil((B*Ir).imag)*1j
Vs = V1+V2                   #Sending end voltage per phase
theta1 = math.atan(Vs.imag/Vs.real)
Is = C*Vr+D*Ir                    #Sending end current
theta2 = math.atan(Is.imag/Is.real)
phys = theta2-theta1
Ps = 3*abs(Vs)*abs(Is)*math.cos(phys)   #Sending-end power(W)
n = Pr/Ps*100                      #efficiency(%)

#Result:
print "(i)  Sending end voltage is",round(abs(Vs)),"V"
print "(ii) Sending end current is",round(abs(Is)),"A"
print "(iii)Sending-end power is",round(Ps/10**6,1),"MW"
print "(iv) Transmission efficiency is",round(n,1),"%"

(i)  Sending end voltage is 87429.0 V
(ii) Sending end current is 246.0 A
(iii)Sending-end power is 48.7 MW
(iv) Transmission efficiency is 82.2 %