Scribd
Upload
2K views5 pages

Transmission Line Calculator in Python

This document contains code for calculating electrical parameters for a short transmission line. It imports mathematical and GUI libraries, defines functions to perform calculations for lagging and leading power factors, and sets up a GUI with entries for input values and labels to display output values. The functions perform calculations using the input values and display the results.

Uploaded by

Mark Mercado
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
2K views5 pages

Transmission Line Calculator in Python

This document contains code for calculating electrical parameters for a short transmission line. It imports mathematical and GUI libraries, defines functions to perform calculations for lagging and leading power factors, and sets up a GUI with entries for input values and labels to display output values. The functions perform calculations using the input values and display the results.

Uploaded by

Mark Mercado
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
  • Calculations
  • Application GUI Setup

from math import *

from numpy import *


from tkinter import *
from tkinter import ttk

def calculate1(*args):
try:
vr = float([Link]())
mw = float([Link]())
pf = float([Link]())
z = float([Link]())
zan = float([Link]())
y = float([Link]())
yan = float([Link]())
x = float([Link]())
pfl = ([Link]())
if pfl == 'lagging' or "lag":
ang = -acos(pf/100)
num1 = mw*1000000*exp(1j*ang)
den1 = vr*pf*10
quo = num1/den1
zt = z*exp(1j*deg2rad(zan))
vs = vr*1000 + quo*zt*x
vsang = angle(vs)
ps = (abs(vs)/1000000*abs(quo)*cos(vsang - ang))

[Link](( round(abs(vs/1000), 3)))


[Link](round(rad2deg(angle(vs)),3))
[Link](round(abs(quo / 1.732050808), 3))
[Link](round(abs(vs)/1000000*abs(quo)*cos(vsang - ang),3))
[Link](round( mw*100/ps,3))

print(abs(vs))

elif pfl == 'leading' or 'lead':


ang = acos(pf/100)
num1 = mw * 1000000 * exp(1j * ang)
den1 = vr * pf * 10
quo = num1 / den1
zt = z * exp(1j * deg2rad(zan))
vs = vr * 1000 + quo * zt * x
vsang = angle(vs)
ps = (abs(vs) / 1000000 * abs(quo) * cos(vsang - ang))

[Link]((round(abs(vs)/1000, 3)))
[Link](round(rad2deg(angle(vs)),3))
[Link](round(abs(quo/1.732050808),3))
[Link](round(abs(vs) / 1000000 * abs(quo) * cos(vsang - ang), 3))
[Link](round( mw*100/ps,3))

except ValueError:
pass

def calculate2(*args):
try:
vr = float([Link]())
mw = float([Link]())
pf = float([Link]())
z = float([Link]())
zan = float([Link]())
y = float([Link]())
yan = float([Link]())
x = float([Link]())
pfl = ([Link]())
if pfl == 'lagging' or "lag":
ang = -acos(pf/100)
num1 = mw*1000000*exp(1j*ang)
den1 = vr*pf*10
quo = num1/den1
zt = z*exp(1j*deg2rad(zan))
vs = vr*1000 + quo*zt*x
vsang = angle(vs)
ps = (abs(vs)/1000000*abs(quo)*cos(vsang - ang))

[Link](( round(abs(vs/1000), 3)))


[Link](round(rad2deg(angle(vs)),3))
[Link](round(abs(quo / 1.732050808), 3))
[Link](round(abs(vs)/1000000*abs(quo)*cos(vsang - ang),3))
[Link](round( mw*100/ps,3))

print(abs(vs))

elif pfl == 'leading' or 'lead':


ang = acos(pf/100)
num1 = mw * 1000000 * exp(1j * ang)
den1 = vr * pf * 10
quo = num1 / den1
zt = z * exp(1j * deg2rad(zan))
vs = vr * 1000 + quo * zt * x
vsang = angle(vs)
ps = (abs(vs) / 1000000 * abs(quo) * cos(vsang - ang))

[Link]((round(abs(vs)/1000, 3)))
[Link](round(rad2deg(angle(vs)),3))
[Link](round(abs(quo/1.732050808),3))
[Link](round(abs(vs) / 1000000 * abs(quo) * cos(vsang - ang), 3))
[Link](round( mw*100/ps,3))

except ValueError:
pass

def calculate3(*args):
try:
vr = float([Link]())
mw = float([Link]())
pf = float([Link]())
z = float([Link]())
zan = float([Link]())
y = float([Link]())
yan = float([Link]())
x = float([Link]())
pfl = ([Link]())
if pfl == 'lagging' or "lag":
ang = -acos(pf/100)
num1 = mw*1000000*exp(1j*ang)
den1 = vr*pf*10
quo = num1/den1
zt = z*exp(1j*deg2rad(zan))
vs = vr*1000 + quo*zt*x
vsang = angle(vs)
ps = (abs(vs)/1000000*abs(quo)*cos(vsang - ang))

[Link](( round(abs(vs/1000), 3)))


[Link](round(rad2deg(angle(vs)),3))
[Link](round(abs(quo / 1.732050808), 3))
[Link](round(abs(vs)/1000000*abs(quo)*cos(vsang - ang),3))
[Link](round( mw*100/ps,3))

print(abs(vs))

elif pfl == 'leading' or 'lead':


ang = acos(pf/100)
num1 = mw * 1000000 * exp(1j * ang)
den1 = vr * pf * 10
quo = num1 / den1
zt = z * exp(1j * deg2rad(zan))
vs = vr * 1000 + quo * zt * x
vsang = angle(vs)
ps = (abs(vs) / 1000000 * abs(quo) * cos(vsang - ang))

[Link]((round(abs(vs)/1000, 3)))
[Link](round(rad2deg(angle(vs)),3))
[Link](round(abs(quo/1.732050808),3))
[Link](round(abs(vs) / 1000000 * abs(quo) * cos(vsang - ang), 3))
[Link](round( mw*100/ps,3))

except ValueError:
pass

root = Tk()
[Link]("TRANSMISSION")
#[Link]("280x480")

mainframe = [Link](root, padding="6 6 12 12")


[Link](column=0, row=0, sticky=(N, W, E, S))
[Link](0, weight=1)
[Link](0, weight=1)
[Link](0, weight=1)
[Link](0, weight=1)

#rows = 0
#while rows < 50:
# [Link](rows, weight=1)
# [Link](rows, weight=1)
# rows += 1

nb = [Link](root, padding = "12 12 12 12")


[Link](column=0, row=0, sticky=(N, W, E, S))
[Link](0, weight=1)
[Link](0, weight=1)
# Adds tab 1 of the notebook
page1 = [Link](nb)
[Link](page1, text='Tab1')

# Adds tab 2 of the notebook


page2 = [Link](nb)
[Link](page2, text='Tab2')

parent=StringVar()
voltage = StringVar()
megaw = StringVar()
pfactor = StringVar()
impe = StringVar()
zang = StringVar()
dist = StringVar()
lela = StringVar()
admi = StringVar()
yang = StringVar()
vsend = StringVar()
vsang2 = StringVar()
is1 = StringVar()
psend = StringVar()
eff = StringVar()

voltage_entry = [Link](page1, width=6, textvariable=voltage)


voltage_entry.grid(column=2, row=2, sticky=(W, E))

megaw_entry = [Link](page1, width=2, textvariable=megaw)


megaw_entry.grid(column=2, row=3, sticky=(W, E))

pfactor_entry = [Link](page1, width=2, textvariable=pfactor)


pfactor_entry.grid(column=2, row=4, sticky=(W, E))

lela_entry = [Link](page1, width=2, textvariable=lela)


lela_entry.grid(column=2, row=5, sticky=(W, E))

impe_entry = [Link](page1, width=2, textvariable=impe)


impe_entry.grid(column=2, row=6, sticky=(W, E))

zang_entry = [Link](page1, width=2, textvariable=zang)


zang_entry.grid(column=2, row=7, sticky=(W, E))

admi_entry = [Link](page1, width=2, textvariable=admi)


admi_entry.grid(column=2, row=8, sticky=(W, E))

yang_entry = [Link](page1, width=2, textvariable=yang)


yang_entry.grid(column=2, row=9, sticky=(W, E))

dist_entry = [Link](page1, width=2, textvariable=dist)


dist_entry.grid(column=2, row=10, sticky=(W, E))

[Link](page2, textvariable=vsend).grid(column=3, row=12, columnspan=5, sticky=W)


[Link](page2, textvariable=vsang2).grid(column=3, row=13, sticky=E)
[Link](page2, textvariable=is1).grid(column=3, row=14, sticky=E)
[Link](page2, textvariable=psend).grid(column=3, row=15, sticky=E)
[Link](page2, textvariable=eff).grid(column=3, row=16, sticky=E)
[Link](page1, text="Calculate", command=calculate1).grid(column=3, row=12,
columnspan=1, sticky=E)
[Link](page1, text=" INPUT GIVEN").grid(column=2, row=1,columnspan =
2 ,sticky=(W, E))
[Link](page1, text="Voltage Receiving (in kV)").grid(column=3, row=2, sticky=W)
[Link](page1, text="Power Receiving (in MW)").grid(column=3, row=3, sticky=W)
[Link](page1, text="Power Factor (in %)").grid(column=3, row=4, sticky=W)
[Link](page1, text="'Leading' or 'Lagging'").grid(column=3, row=5, sticky=W)
[Link](page1, text="Impedance (r)").grid(column=3, row=6, sticky=W)
[Link](page1, text="Impedance Angle (?)").grid(column=3, row=7, sticky=W)
[Link](page1, text="Admittance (r)").grid(column=3, row=8, sticky=W)
[Link](page1, text="Admittance Angle (?)").grid(column=3, row=9, sticky=W)
[Link](page1, text="Distance (m)").grid(column=3, row=10, sticky=W)

[Link](page2, text=" SHORT TRANSMISSION LINE ").grid(column=2, row=1,


columnspan = 3, sticky=W)
[Link](page2, text=" ").grid(column=4, row=2, sticky=W)
[Link](page2, text="Voltage Sending").grid(column=2, row=12, sticky=E)
[Link](page2, text="Current Sending").grid(column=2, row=14, sticky=E)
[Link](page2, text="Voltage Sending Angle").grid(column=2, row=13, sticky=E)
[Link](page2, text="Power Sending").grid(column=2, row=15, sticky=E)
[Link](page2, text="Efficiency").grid(column=2, row=16, sticky=E)
[Link](page2, text="kV").grid(column=4, row=12, sticky=W)
[Link](page2, text="degrees").grid(column=4, row=13, sticky=W)
[Link](page2, text="Ampere").grid(column=4, row=14, sticky=W)
[Link](page2, text="MW").grid(column=4, row=15, sticky=W)
[Link](page2, text="%").grid(column=4, row=16, sticky=W)

for child in page1.winfo_children(): child.grid_configure(padx=5, pady=5)


for child in page2.winfo_children(): child.grid_configure(padx=5, pady=5)

voltage_entry.focus()
[Link]('<Return>', calculate1)

[Link]()

Common questions

Powered by AI

The program differentiates between 'leading' and 'lagging' scenarios by adjusting the phase angle calculation for the power factor correction. For 'lagging' scenarios, the angle is negated using the negative function of the acos method, indicating the phase delay. However, for 'leading' scenarios, the positive angle from the acos function is applied, reflecting the phase advance. This distinction affects the current and voltage phase relationship, influencing the resulting power calculation .

The program effectively handles user interaction by providing a well-structured interface with clearly labeled input fields, facilitating accurate data entry. The use of a Notebook widget to organize related inputs and outputs into tabs enhances the usability by segmenting complex information. Error handling through try-except blocks ensures that incorrect entries do not disrupt the user experience. Additionally, the grid layout provides a visually appealing and easy-to-follow structure for both input and output displays, making the application intuitive and user-friendly .

The program utilizes complex numbers to accurately represent phasors in the electrical calculations. For instance, it computes the current quotient (quo) by dividing the received power into complex exponential form and uses this form to determine the product with the complex impedance (zt), which is also expressed using complex exponential terms. This allows for accurate calculation of phase angles and magnitude, which are essential in determining voltage, current, and power quantities in AC circuits .

The imported mathematical functions from the 'math' and 'numpy' libraries are essential for handling complex numbers and trigonometric operations required in transmission line calculations. 'exp' and 'angle' functions from 'numpy' are used for complex exponentials and phase angle computation, while trigonometric functions like 'acos' provide phase angle adjustments based on power factor. The 'deg2rad' and 'rad2deg' conversions help transition between degree and radian systems, important for mathematical accuracy in engineering contexts .

The transmitting power's efficiency is calculated by dividing the received power (in MW) by the sending power (in MW) and then multiplying by 100 to convert it into a percentage. The sending power is represented by PS, calculated from the absolute values of the sending voltage (VS) and the current quotient, considering the phase difference calculated from the angle of VS and the power factor angle .

The GUI, created using the Tkinter library, is structured with a main window divided into tabs using a Notebook widget. Each tab contains input and output elements organized through columns and rows to facilitate data entry and display results. Entry widgets are used for user input fields, while Label widgets display output. The layout is managed with grid geometry, which aligns items in a flexible and responsive manner. Command bindings to buttons trigger calculations, enhancing user interaction with the application .

The application uses try-except blocks around the main calculation functions to manage user input errors. If a ValueError arises due to invalid input, such as non-numeric values or other data entry errors, the except clause catches it, preventing the program from crashing and allowing users to input correct values .

The variable 'z' represents the impedance magnitude, while 'zan' represents the impedance angle in degrees. These variables are used to compute the complex impedance zt in polar form, which is essential for calculating voltage and current phasors through multiplication by the current quotient. This computation of impedance in polar form is a critical step in solving transmission line problems using phasor analysis .

The program determines the phase angle for power factor correction by first checking if the power factor is 'lagging' or 'leading'. For lagging power factors, the angle is calculated using -acos(pf/100) which converts the power factor percentage to a phase angle in radians. For leading power factors, it uses acos(pf/100) to calculate the angle. This distinction is crucial in ensuring the correct phase shift direction is applied .

Calculation results for voltage, current, and power outputs are visually represented using Label widgets in the GUI. These widgets display the computed values with appropriate units, such as kV, MW, and percentages, next to descriptive text. The labels update dynamically following the completion of calculations, ensuring that users have immediate and clear feedback from their inputs .

You might also like