def test_addition(self):
admittance_1 = Admittance(impedance=Impedance(5, 2))
admittance_2 = Admittance(impedance=Impedance(3, 6))
admittance_1 += admittance_2
print("")
print("G = " + str(admittance_1.get_real_part()))
print("B = " + str(admittance_1.get_imaginary_part()))
def test_subtraction(self):
admittance_1 = Admittance(g=5, b=2)
admittance_2 = Admittance(g=3, b=6)
admittance_1 -= admittance_2
print("")
print("G = " + str(admittance_1.get_real_part()))
print("B = " + str(admittance_1.get_imaginary_part()))
def test_division(self):
admittance_1 = Admittance(impedance=Impedance(0.16, -0.12))
admittance_2 = Admittance(g=2, b=2)
admittance_1 /= admittance_2
print("")
print("G = " + str(admittance_1.get_real_part()))
print("B = " + str(admittance_1.get_imaginary_part()))
def __set_line_parameters(self, line_parameters):
if line_parameters:
# Leitungslaenge
self.__length = line_parameters['length']
# resistiver Laengswiderstand
self.__resistance = line_parameters['r_l'] * self.__length
# induktiver Laengswiderstand
self.__inductive_reactance = line_parameters['x_l'] * self.__length
# resistiver Querwiderstand
self.__transverse_resistance = line_parameters[
'g_shunt_l'] * self.__length
# kapazitiver Querwiderstand
self.__capacitive_reactance = line_parameters[
'b_shunt_l'] * self.__length
else:
LoadFlowReporter.error_report.append(
"Coudn't read line_parameters.")
print(LoadFlowReporter.error_report)
# Laengsimpedanz der Leitung
if self.__resistance or self.__inductive_reactance:
self.__impedance = Impedance(self.__resistance,
self.__inductive_reactance)
# Laengsadmittanz der Leitung
if self.__impedance is not None:
self.__admittance = Admittance(impedance=self.__impedance)
# Queradmittanz der Leitung
# if self.__transverse_impedance is not None:
self.__transverse_admittance = Admittance(
g=self.__transverse_resistance, b=self.__capacitive_reactance)
# Knoten-Queradmittanz der Leitung bezogen auf einen Knoten, entspricht halben Queradmittanz-Wert
if self.__transverse_admittance is not None:
self.__transverse_admittance_on_node = Admittance(
g=((self.__transverse_admittance.get_real_part() / 2)
if self.__transverse_admittance.get_real_part() else None),
b=((self.__transverse_admittance.get_imaginary_part() / 2))
if self.__transverse_admittance.get_imaginary_part() else None)
def __set_transformer_parameters(self, transformer_parameters):
# resistiver Laengswiderstand der Kurzschlussimpedanz
if transformer_parameters[0]:
self.__r = transformer_parameters[0]
if transformer_parameters[1]:
self.__x = transformer_parameters[1]
if transformer_parameters[2]:
self.__g = transformer_parameters[2]
if transformer_parameters[3]:
self.__b = transformer_parameters[3]
if transformer_parameters[4]:
self.__tap_ratio = transformer_parameters[4]
if transformer_parameters[5]:
self.__phase_shift = transformer_parameters[5]
if transformer_parameters[6]:
self.__s_n = transformer_parameters[6]
else:
LoadFlowReporter.error_report.append("Transformer ERROR")
print(LoadFlowReporter.error_report)
# Kurzschlussimpedanz des Transformators
if self.__r and self.__x:
self.__sc_impedance = Impedance(self.__r, self.__x)
# Kurzschlussadmittanz des Transformators
if self.__sc_impedance is not None:
self.__sc_admittance = Admittance(impedance=self.__sc_impedance)
# Shunt-Admittanz des Transformators
if self.__g and self.__b:
self.__shunt_admittance = Admittance(g=self.__g, b=self.__b)
# Shunt-Impedanz des Transformators
if self.__shunt_admittance is not None:
self.__shunt_impedance = Impedance(
admittance=self.__shunt_admittance)
def __get_sum_of_grid_lines_on_node(self, node_name_i, node_name_j):
"""
Methode zur Aufsummierung aller Admittanzen an einem Knoten
Parameter:
Knotennamen,
[Optional] Modus: True|False (all_admittances), Wenn True: werden alle Laengs- und Queradmittanzen aufsummiert.
Wenn False: werden nur die Längsadmittanzen aufsummiert (Queradmittanzen werden igoniert)
Rückgabewert: kummulierter Admittanzenwert
Quelle: E. Handschin, Elektrische Energieübertragungssysteme. Teil 1: Stationaerer Betriebszustand.
Heidelberg: Hueting, 1983, Seite 51
:param node_name_i:
:param node_name_j:
:return:
"""
# Summenadmittanz an Knoten i und entspricht einem Element der Knotenadmittanzmatrix (KAM)
sum_admittance = Admittance(g=0, b=0)
# Ist Diagonalelement ?
is_diag_elem = node_name_i == node_name_j
for bus_connecter in self.__bus_connecter_list:
# pruefen ob das Objekt eine Leitung ist
is_line = isinstance(bus_connecter, GridLine)
if is_line:
# echte Kopien der Längs- und Queradmittanz erzeugen
bus_connecter_admittance = copy.deepcopy(
bus_connecter.get_admittance()) if bus_connecter else 0
bus_connecter_transverse_admittance = copy.deepcopy(
bus_connecter.get_transverse_admittance_on_node(
)) if bus_connecter else 0
else:
# echte Kopie der Kurzschlussimpedanz des Transformators erstellen
bus_connecter_admittance = copy.deepcopy(
bus_connecter.get_sc_admittance()) if bus_connecter else 0
bus_connecter_transverse_admittance = None
# SPÄTER DIE SHUNT IMPEDANZ HINZUFUEGEN
# bus_connecter_transverse_admittance = copy.deepcopy(
# bus_connecter.get_transverse_admittance_on_node()) if bus_connecter else 0
# pruefen ob Leitung beide Knoten verbindet
is_element_connecting_i_j = bus_connecter.get_node_name_i() == node_name_i and \
bus_connecter.get_node_name_j() == node_name_j or \
bus_connecter.get_node_name_i() == node_name_j and \
bus_connecter.get_node_name_j() == node_name_i
# Prüfen ob Diagonalelement
if is_diag_elem:
# Addiere Längsadmittanz von Gridline zur Summenadmittanz
sum_admittance += bus_connecter_admittance
# Prüfen ob Queradmittanz in Gridline vorhanden
if bus_connecter_transverse_admittance:
# Addiere Knoten-Queradmittanz von Gridline zur Summenadmittanz
sum_admittance += bus_connecter_transverse_admittance
else:
if is_element_connecting_i_j:
# Addiere Längsadmittanz von Gridline zur Summenadmittanz
sum_admittance += bus_connecter_admittance
return sum_admittance if is_diag_elem else sum_admittance * -1
def set_transverse_admittance(self, real_part, imag_part):
self.__transverse_admittance = Admittance(g=real_part, b=imag_part)
def set_admittance(self, real_part, imag_part):
self.__admittance = Admittance(g=real_part, b=imag_part)
class GridLine:
# Initialisierungs-Konstruktor
# name = Leitungsbezeichnung
# node_i = Anfangsknoten
# node_j = Endknoten
# lineParameters: [0,1,2,3,4]
# [0] -> [Leitungslaenge] = km
# [1] -> r [resistiver Längswiderstand] = Ω
# [2] -> x [induktiver Längswiderstand] = Ω
# [3] -> g [resistiver Querleitungswiderstand] = 1/Ω
# [4] -> b [kapazitiver Querleitungwert] = 1/Ω
def __init__(self, name, node_name_i, node_name_j, line_parameters):
# Leitungsbezeichnung
self.__name = name
# Knoten 1
self.__node_name_i = node_name_i
# Knoten 2
self.__node_name_j = node_name_j
# Laenge der Leitung
self.__length = None
# resistiver Laengswiderstand
self.__resistance = None
# induktiver Laengswiderstand
self.__inductive_reactance = None
# resistiver Querwiderstand
self.__transverse_resistance = None
# kapazitiver Querwiderstand
self.__capacitive_reactance = None
# Laengsimpedanz der Leitung
self.__impedance = None
# Laengsadmittanz der Leitung
self.__admittance = None
# Querimpedanz der Leitung
self.__transverse_impedance = None
# Queradmittanz der Leitung
self.__transverse_admittance = None
# Queradmittanz der Leitung an einem Knoten,entspricht halben Queradmittanz-Wert der Leitung
self.__transverse_admittance_on_node = None
# Leitungsparameter setzen
self.__set_line_parameters(line_parameters)
# getter-Methoden
def __get_name(self):
return self.__name
def get_node_name_i(self):
return self.__node_name_i
def get_node_name_j(self):
return self.__node_name_j
def get_admittance(self):
return self.__admittance
def get_transverse_admittance_on_node(self):
return self.__transverse_admittance_on_node
name = property(__get_name)
# node_i = property(__get_node_name_i)
# node_j = property(__get_node_name_j)
# admittance = property(__get_admittance)
# shunt_admittance = property(__get_transverse_admittance_on_node)
def set_admittance(self, real_part, imag_part):
self.__admittance = Admittance(g=real_part, b=imag_part)
def set_transverse_admittance(self, real_part, imag_part):
self.__transverse_admittance = Admittance(g=real_part, b=imag_part)
# Methode setzt die Leitungsbelaege (Ω/km) als Parameter
def __set_line_parameters(self, line_parameters):
if line_parameters:
# Leitungslaenge
self.__length = line_parameters['length']
# resistiver Laengswiderstand
self.__resistance = line_parameters['r_l'] * self.__length
# induktiver Laengswiderstand
self.__inductive_reactance = line_parameters['x_l'] * self.__length
# resistiver Querwiderstand
self.__transverse_resistance = line_parameters[
'g_shunt_l'] * self.__length
# kapazitiver Querwiderstand
self.__capacitive_reactance = line_parameters[
'b_shunt_l'] * self.__length
else:
LoadFlowReporter.error_report.append(
"Coudn't read line_parameters.")
print(LoadFlowReporter.error_report)
# Laengsimpedanz der Leitung
if self.__resistance or self.__inductive_reactance:
self.__impedance = Impedance(self.__resistance,
self.__inductive_reactance)
# Laengsadmittanz der Leitung
if self.__impedance is not None:
self.__admittance = Admittance(impedance=self.__impedance)
# Queradmittanz der Leitung
# if self.__transverse_impedance is not None:
self.__transverse_admittance = Admittance(
g=self.__transverse_resistance, b=self.__capacitive_reactance)
# Knoten-Queradmittanz der Leitung bezogen auf einen Knoten, entspricht halben Queradmittanz-Wert
if self.__transverse_admittance is not None:
self.__transverse_admittance_on_node = Admittance(
g=((self.__transverse_admittance.get_real_part() / 2)
if self.__transverse_admittance.get_real_part() else None),
b=((self.__transverse_admittance.get_imaginary_part() / 2))
if self.__transverse_admittance.get_imaginary_part() else None)
# Bildschirmausgabe der Leitungsparameter
def __str__(self):
result = ""
result += "\n\n----------------------------------"
result += "\nLEITUNG/KABEL"
result += "\nLeitungsbezeichnung: " + str(self.__name)
result += "\nKnoten 1: " + str(self.__node_name_i)
result += "\nKnoten 2: " + str(self.__node_name_j)
result += "\nLänge: " + str(self.__length) + " km " + "--> " + str(
self.__length * 1000) + " m"
result += "\nLängswiderstand: " + str(self.__resistance) + " Ω"
result += "\ninduktiver Längswiderstand: " + str(
self.__inductive_reactance) + " Ω"
result += "\nQuerwiderstand: " + str(self.__transverse_resistance)
result += "\nkapazitiver Querwiderstand: " + str(
self.__capacitive_reactance) + " Ω"
result += "\nImpedanz: " + str(self.__impedance.get_magnitude()) + " Ω"
result += "\nAdmittanz: " + str(
self.__admittance.get_magnitude()) + " S"
result += "\nQuer-Impedanz: " + str(self.__transverse_impedance) + " Ω"
result += "\nQuer-Admittanz: " + str(
self.__transverse_admittance) + " S"
return result