def sistema_viz(resultados, rede):
'''
Esta função gera um gráfico de pontos (scatter plot) mostrando os níveis de tensão e ângulos de tensão de
todas as barras do sistema; gera uma visualização do sistema elétrico correspondente na forma de um grafo;
gera também uma tabela contendo os valores das variáveis discretas obtidas.
Inputs:
-> resultados: saída da função otimizar_alcateia
-> rede
Outputs:
-> v_plot: gráfico scatter contendo os níveis de tensão das barras do sistema;
-> ang_plot: gráfico scatter contendo os ângulos de tensão das barras do sistema;
-> sis_graph: visualização do sistema elétrico na forma de um grafo;
-> tabela_discretos: string contendo a tabela das variáveis discretas no formato latex
'''
#Extrai o lobo alfa da entrada 'resultados'
alfa = resultados['alfa']
#Executar um fluxo de carga com o alfa dado para obter os valores das tensões e ângulos das barras do sistema
v_alfa = alfa[:ng]
taps_alfa = alfa[ng:ng + nt]
shunts_alfa = alfa[ng + nt:ng + nt + ns]
#Inserindo as tensões das barras de geração na rede
rede.gen.vm_pu = v_alfa
#Inserindo os taps dos transformadores
'''
Os taps dos transformadores devem ser inseridos como valores de posição,
e não como seu valor em pu. Para converter de pu para posição é utilizada a seguinte equação:
tap_pos = [(tap_pu - 1)*100]/tap_step_percent] + tap_neutral
O valor tap_mid_pos é 0 no sistema de 14 barras
'''
rede.trafo.tap_pos[:nt] = rede.trafo.tap_neutral[:nt] + (
(taps_alfa - 1.0) * (100 / rede.trafo.tap_step_percent[:nt]))
#Inserindo as susceptâncias shunt
"""
A unidade de susceptância shunt no pandapower é MVAr e seu sinal é negativo.
Para transformar de pu para MVAr negativo basta multiplicar por -100
"""
rede.shunt.q_mvar = shunts_alfa * (-100)
pp.runpp(rede, algorithm='nr', numba=True, init='results')
#Obtendo as tensões e ângulos das barras do sistema
tensoes = rede.res_bus.vm_pu.to_numpy(dtype=np.float32)
angulos = rede.res_bus.va_degree.to_numpy(dtype=np.float32)
#Gráfico das tensões
v_plot = plt.figure(figsize=(0.56 * 20, 0.56 * 10))
barras = np.arange(1, nb + 1, step=1)
plt.scatter(barras, tensoes, marker='o', figure=v_plot)
plt.xlabel('Barras', figure=v_plot)
plt.ylabel('Nível de tensão (pu)', figure=v_plot)
plt.grid(True, figure=v_plot)
plt.xticks(barras, figure=v_plot)
plt.yticks(np.arange(rede.bus.min_vm_pu.to_numpy(dtype=np.float32)[0],
rede.bus.max_vm_pu.to_numpy(dtype=np.float32)[0] +
0.01,
step=0.01),
figure=v_plot)
#Gráfico dos ângulos
ang_plot = plt.figure(figsize=(0.56 * 20, 0.56 * 10))
plt.scatter(barras, angulos, marker='o', figure=ang_plot)
plt.xlabel('Barras', figure=ang_plot)
plt.ylabel(r'Angulos de tensão ($^o$)', figure=ang_plot)
plt.grid(True, figure=ang_plot)
plt.xticks(barras, figure=ang_plot)
#Grafo do sistema elétrico
sis_graph = pplot.simple_plot(rede)
#Tabela com as variáveis discretas
table = []
for idx, tap in enumerate(taps_alfa):
table.append([
't_' + str(rede.trafo.hv_bus[idx] + 1) + '-' +
str(rede.trafo.lv_bus[idx] + 1), tap
])
del idx
for idx, shunt in enumerate(shunts_alfa):
table.append(['b^sh_' + str(rede.shunt.bus[idx] + 1), shunt])
table = tabulate.tabulate(table,
headers=['Variáveis discretas', 'Valores (pu)'],
tablefmt="psql")
print(table)
return v_plot, ang_plot, sis_graph, table
pp.create_measurement(net, "q", "line", 0.663, .008, element=l2, side=b1) # Qline (bus 1 -> bus 3) at bus 1
net.measurement
success = estimate(net, init='flat')
print(success)
net.res_line_est
net.res_bus_est
pp.runpp(net, calculate_voltage_angles=True, init="dc")
plt.figure(1)
plot.simple_plot(net)
plt.savefig('3busbar.png')c
pf_res_est_plotly(net)
pf_res_plotly(net)
net
net.bus
net.res_line_est
net.res_bus
net.res_bus_est
net.line
net.res_line_est
# create feeders
create_dickert_lv_feeders(net=net,
busbar_index=busbar_index,
feeders_range=feeders_range,
linetype=linetype,
customer=customer,
case=case)
return net
if __name__ == "__main__":
if 0:
feeders_range = 'middle'
linetype = 'C&OHL'
customer = 'multiple'
case = 'bad'
trafo_type_name = '0.4 MVA 20/0.4 kV'
trafo_type_data = None
net = create_dickert_lv_network(feeders_range=feeders_range,
linetype=linetype,
customer=customer,
case=case,
trafo_type_name=trafo_type_name,
trafo_type_data=trafo_type_data)
from pandapower.plotting import simple_plot
simple_plot(net)
else:
pass
import pandapower as pp
import pandapower.networks as pn
import numpy as np
import pandapower.plotting as plot
import matplotlib.pyplot as plt
from pandapower.plotting.plotly import vlevel_plotly
import pandas as pd
net = pn.create_cigre_network_lv()
net
plot.simple_plot(net, show_plot=True)
vlevel_plotly(net)
#del net.bus_geodata
pp.convert_format(net)
pp.to_excel(net, "examplecigrelow.xlsx")
netcoords = net.bus_geodata
netcoords.to_excel('cigrecoords.xlsx')
netlv = pp.from_excel("final code/examplecigrelow.xlsx")
#lv.bus_geodata
#del netlv.bus_geodata
netlv
plot.simple_plot(netlv, show_plot=True)
vlevel_plotly(netlv)
#vlevel_plotly(net)
netlv
net
import pandapower.networks as nw
import pandapower.plotting as pplt
import matplotlib.pyplot as plt
net = nw.create_cigre_network_mv()
# limits
vmax = 1.05
vmin = .95
max_ll = 100.
lines = net.line.index
critical = list()
for l in lines:
net.line.loc[l, "in_service"] = False
pp.runpp(net)
if net.res_bus.vm_pu.max() > vmax or net.res_bus.vm_pu.min(
) < vmin or net.res_line.loading_percent.max() > max_ll:
critical.append(l)
net.line.loc[l, "in_service"] = True
ax = pplt.simple_plot(net, show_plot=False)
clc = pplt.create_line_collection(net,
critical,
color="r",
linewidth=3.,
use_bus_geodata=True)
pplt.draw_collections([clc], ax=ax)
plt.show()
import pandapower as pp
import numpy as np
import pandapower.plotting as plot
import matplotlib.pyplot as plt
import pandas as pd
from pandapower.estimation import estimate
#read overall net from excel file
net = pp.from_excel("final code/circuits/net3.xlsx")
plot.simple_plot(net,
show_plot=True,
trafo_size=1.25,
plot_loads=True,
plot_sgens=True)
####INDUSTRIAL FEEDER###########
ind_feeder = pp.from_excel("final code/circuits/ind_feeder.xlsx")
plot.simple_plot(ind_feeder,
show_plot=True,
trafo_size=1.5,
plot_loads=True,
plot_sgens=True)
####RESIDENTIAL FEEDER###########
res_feeder = pp.from_excel("final code/circuits/res_feeder.xlsx")
plot.simple_plot(res_feeder,
show_plot=True,
trafo_size=1.5,
plot_loads=True,
plot_sgens=True)
'''
'''
This is a kind of similiar approach as in the case of load, I have searched for name
of Machine from dictionary connected to particular node.
'''
for elementa in range(len(SynchMachineValue)):
name = SynchMachineValue[elementa].name
sn_mva = float(SynchMachineValue[elementa].rated_S)
p_mw = float(SynchMachineValue[elementa].s_real)
for elementb in range(len(NodeValue)):
for elementc in range(len(NodeValue[elementb].conn_eqp)):
if SynchMachineValue[elementa].name == NodeValue[
elementb].conn_eqp[elementc]:
bus = pp.pp.get_element_index(net, "bus",
NodeValue[elementb].name)
generator = pp.create_gen(net, bus, p_mw, 1, sn_mva, name)
print("\n" 'Generator')
print(net.gen)
'''
# Network plotting
'''
'''
plotting from the equipments created in the system in the pandapower
'''
import pandapower.plotting as pp_plot
pp_plot.simple_plot(net, line_width=2.0, bus_size=2.0, trafo_size=4.0, plot_loads=True, load_size=6.0, sgen_size=4.0, switch_size=4.0, switch_distance=4,\
plot_line_switches=True, scale_size=True, bus_color='r',\
line_color='b',trafo_color='g',switch_color='k')
# Youtube Tutorial: https://www.youtube.com/watch?v=QYDp_-TX7C4
import pandapower as pp
import pandapower.plotting as pplt
import pandapower.topology as top
import pandapower.networks as nw
import matplotlib.pyplot as plt
import seaborn as sns
net = nw.mv_oberrhein()
pplt.simple_plot(net)
mg = top.create_nxgraph(net, nogobuses=set(net.trafo.lv_bus.values) | set(net.trafo.hv_bus.values))
colors = sns.color_palette()
collections = list()
sizes = pplt.get_collection_sizes(net)
for area, color in zip(top.connected_components(mg), colors):
collections.append(pplt.create_bus_collection(net, area, color=color, size=sizes["bus"]))
line_ind = net.line.loc[:, "from_bus"].isin(area) | net.line.loc[:, "to_bus"].isin(area)
lines = net.line.loc[line_ind].index
collections.append(pplt.create_line_collection(net, lines, color=color))
collections.append(pplt.create_ext_grid_collection(net, size=sizes["ext_grid"]))
pplt.draw_collections(collections)
plt.show()
def plot_grid(self):
plot.simple_plot(self._net, show_plot=True)
import pandapower.networks as nw1 import pandapower as pp from pandapower.plotting import simple_plot, simple_plotly, pf_res_plotly net1 = nw1.mv_oberrhein() pp.runpp(net1) print(net1.res_bus) highest = net1.res_bus.vm_pu.max() print(highest) highest_ones = net1.res_bus.loc[net1.res_bus.vm_pu > 1.02] print(highest_ones) lines = net1.res_line.loc[net1.res_line.loading_percent > 50.] print(lines) simple_plot(net1) simple_plotly(net1) print()
