def test_create_realistic():
net = pn.example_multivoltage()
pp.runpp(net)
all_vn_kv = pd.Series([380, 110, 20, 10, 0.4])
assert net.bus.vn_kv.isin(all_vn_kv).all()
assert len(net.bus) >= 1
assert len(net.line) >= 1
assert len(net.gen) >= 1
assert len(net.sgen) >= 1
assert len(net.shunt) >= 1
assert len(net.trafo) >= 1
assert len(net.trafo3w) >= 1
assert len(net.load) >= 1
assert len(net.ext_grid) >= 1
assert len(net.switch[net.switch.et == 'l']) >= 1
assert len(net.switch[net.switch.et == 'b']) >= 1
assert len(net.switch[net.switch.et == 't']) >= 1
assert len(net.switch[net.switch.type == 'CB']) >= 1
assert len(net.switch[net.switch.type == 'DS']) >= 1
assert len(net.switch[net.switch.type == 'LBS']) >= 1
assert len(net.switch[net.switch.closed]) >= 1
assert len(net.switch[~net.switch.closed]) >= 1
assert len(net.impedance) >= 1
assert len(net.xward) >= 1
assert net.converged
def test_continuous_element_numbering():
from pandapower.estimation.util import add_virtual_meas_from_loadflow
net = nw.example_multivoltage()
# Add noises to index with some large number
net.line.rename(index={4: 280}, inplace=True)
net.trafo.rename(index={0: 300}, inplace=True)
net.trafo.rename(index={1: 400}, inplace=True)
net.trafo3w.rename(index={0: 540}, inplace=True)
net.switch.loc[(net.switch.et == "l") & (net.switch.element == 4),
"element"] = 280
net.switch.loc[(net.switch.et == "t") & (net.switch.element == 0),
"element"] = 300
net.switch.loc[(net.switch.et == "t") & (net.switch.element == 1),
"element"] = 400
pp.runpp(net)
add_virtual_meas_from_loadflow(net)
assert net.measurement["element"].max() == 540
net = tb.create_continuous_elements_index(net)
assert net.line.index.max() == net.line.shape[0] - 1
assert net.trafo.index.max() == net.trafo.shape[0] - 1
assert net.trafo3w.index.max() == net.trafo3w.shape[0] - 1
assert net.measurement["element"].max() == net.bus.shape[0] - 1
def test_merge_parallel_line():
net = nw.example_multivoltage()
pp.runpp(net)
assert net.line.parallel.at[5] == 2
line = net.line.loc[5]
fbus = line.from_bus
tbus = line.to_bus
fbus_0 = net.res_bus.loc[fbus]
tbus_0 = net.res_bus.loc[tbus]
ploss_0 = (net.res_line.loc[5].p_from_mw - net.res_line.loc[5].p_to_mw)
qloss_0 = (net.res_line.loc[5].q_from_mvar - net.res_line.loc[5].q_to_mvar)
net = tb.merge_parallel_line(net,5)
assert net.line.parallel.at[5] == 1
pp.runpp(net)
fbus_1 = net.res_bus.loc[fbus]
tbus_1 = net.res_bus.loc[tbus]
ploss_1 = (net.res_line.loc[5].p_from_mw - net.res_line.loc[5].p_to_mw)
qloss_1 = (net.res_line.loc[5].q_from_mvar - net.res_line.loc[5].q_to_mvar)
assert_series_equal(fbus_0, fbus_1)
assert_series_equal(tbus_0, tbus_1)
assert np.isclose(ploss_0, ploss_1, atol=1e-5)
assert np.isclose(qloss_0, qloss_1)
def test_get_element_indices():
net = nw.example_multivoltage()
idx1 = pp.get_element_indices(net, "bus", ["Bus HV%i" % i for i in range(1, 4)])
idx2 = pp.get_element_indices(net, ["bus", "line"], "HV", exact_match=False)
idx3 = pp.get_element_indices(net, ["bus", "line"], ["Bus HV3", "MV Line6"])
assert [32, 33, 34] == idx1
assert ([32, 33, 34, 35] == idx2[0]).all()
assert ([0, 1, 2, 3, 4, 5] == idx2[1]).all()
assert [34, 11] == idx3
def test_init_results_without_results():
# should switch to "auto" mode and not fail
net = example_multivoltage()
pp.reset_results(net)
pp.runpp(net, init="results")
assert net.converged
pp.reset_results(net)
pp.runpp(net, init_vm_pu="results")
assert net.converged
pp.reset_results(net)
pp.runpp(net, init_va_degree="results")
assert net.converged
pp.reset_results(net)
pp.runpp(net, init_va_degree="results", init_vm_pu="results")
assert net.converged
def test_create_realistic():
net = pn.example_multivoltage()
pp.runpp(net)
assert net.converged
for element in [
"bus", "line", "gen", "sgen", "shunt", "trafo", "trafo3w", "load",
"ext_grid", "impedance", "xward"
]:
assert len(net[element]) >= 1
for et in ["l", "b", "t"]:
assert len(net.switch[net.switch.et == et]) >= 1
for type_ in ["CB", "DS", "LBS"]:
assert len(net.switch[net.switch.type == type_]) >= 1
assert len(net.switch[net.switch.closed]) >= 1
assert len(net.switch[~net.switch.closed]) >= 1
all_vn_kv = pd.Series([380, 110, 20, 10, 0.4])
assert net.bus.vn_kv.isin(all_vn_kv).all()
def create_net3():
""" 57 bus net with all kinds of elements. """
net = pn.example_multivoltage()
net = settings_orpf(net)
# Allow more loading (otherwise no valid solution)
max_loading = 120
net.line['max_loading_percent'] = pd.Series(
[max_loading for _ in net.line.index], index=net.line.index)
max_loading = 110
net.trafo['max_loading_percent'] = pd.Series(
[max_loading for _ in net.trafo.index], index=net.trafo.index)
# Add maximum apparent power additional constraint (as example)
for gen in ('gen', 'sgen'):
max_s = (net[gen].max_p_mw**2 + net[gen].max_q_mvar**2)**0.5
net[gen]['max_s_mva'] = pd.Series(max_s, index=net[gen].index)
return net
def test_voltlvl_idx():
net = pn.example_multivoltage()
hv_and_mv_buses = list(range(16, 45))
assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", 4)
assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", ["HV-MV"])
assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", [3, 5])
assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", ["HV", "MV"])
mv_loads = list(range(5, 13))
assert mv_loads == sb.voltlvl_idx(net, "load", "MV")
hvmv_trafo3ws = [0]
assert hvmv_trafo3ws == sb.voltlvl_idx(net,
"trafo3w",
"HV",
branch_bus="hv_bus")
assert hvmv_trafo3ws == sb.voltlvl_idx(net,
"trafo3w",
"MV",
branch_bus="mv_bus")
assert hvmv_trafo3ws == sb.voltlvl_idx(net,
"trafo3w",
"MV",
branch_bus="lv_bus")
ehvhv_trafos = [0]
assert ehvhv_trafos == sb.voltlvl_idx(net, "trafo", 1, branch_bus="hv_bus")
assert ehvhv_trafos == sb.voltlvl_idx(net, "trafo", 3, branch_bus="lv_bus")
ehvhv_and_hvmv_trafos = [0]
assert ehvhv_and_hvmv_trafos == sb.voltlvl_idx(net,
"trafo",
2,
branch_bus="hv_bus")
assert ehvhv_and_hvmv_trafos == sb.voltlvl_idx(net,
"trafo",
4,
branch_bus="lv_bus")
hvmv_trafos = []
assert hvmv_trafos == sb.voltlvl_idx(net, "trafo", 5, branch_bus="lv_bus")
mvlv_trafos = [1]
assert mvlv_trafos == sb.voltlvl_idx(net, "trafo", 5, branch_bus="hv_bus")
lv_loads = list(range(13, 25))
assert lv_loads == sb.voltlvl_idx(net, "load", 7)
def test_multivoltage_example_with_controller():
do_output = False
net = networks.example_multivoltage()
gen_p_disp = 10
net.gen.p_mw.at[0] = gen_p_disp
net.gen.slack_weight.at[0] = 1
net.ext_grid.slack_weight.at[0] = 1
net.trafo.tap_max.at[1] = 5
net.trafo.tap_min.at[1] = -5
ContinuousTapControl(net, tid=1, vm_set_pu=1.05)
gen_disp = sum([net[elm].p_mw.sum() for elm in ["gen", "sgen"]])
load_disp = sum([net[elm].p_mw.sum() for elm in ["load", "shunt"]]) + \
net.xward[["ps_mw", "pz_mw"]].sum().sum()
expected_losses = 2 # MW
expected_slack_power = load_disp + expected_losses - gen_disp # MW
tol = 0.5 # MW
net2 = net.deepcopy()
# test distributed_slack
run_and_assert_numba(net)
# take results for gen and xward from net to net2 and compare results
net2.gen.p_mw = net.res_gen.p_mw
net2.xward.ps_mw = net._ppc['bus'][
net._pd2ppc_lookups['bus'][net.xward.bus],
PD] - net.load.loc[net.load.bus.isin([34, 32]), 'p_mw'].values
pp.runpp(net2)
assert_res_equal(net, net2)
check_xward_results(net)
assert_results_correct(net)
if do_output:
print("grid losses: %.6f" % -net.res_bus.p_mw.sum())
print("slack generator p results: %.6f %.6f" %
(net.res_ext_grid.p_mw.at[0], net.res_gen.p_mw.at[0]))
net.res_bus.vm_pu.plot()
assert np.isclose(net.res_ext_grid.p_mw.at[0],
net.res_gen.p_mw.at[0] - gen_p_disp)
assert expected_slack_power / 2 - tol < net.res_ext_grid.p_mw.at[
0] < expected_slack_power / 2 + tol
losses_without_controller = -net.res_bus.p_mw.sum()
slack_power_without_controller = net.res_ext_grid.p_mw.at[0] + net.res_gen.p_mw.at[0] - \
gen_p_disp
# test distributed_slack with controller
run_and_assert_numba(net, run_control=True)
check_xward_results(net)
assert_results_correct(net)
losses_with_controller = -net.res_bus.p_mw.sum()
expected_slack_power = slack_power_without_controller - losses_without_controller + \
losses_with_controller
slack_power_without_controller = net.res_ext_grid.p_mw.at[0] + net.res_gen.p_mw.at[0] - \
gen_p_disp
assert np.isclose(expected_slack_power,
slack_power_without_controller,
atol=1e-5)
assert np.isclose(net.res_ext_grid.p_mw.at[0],
expected_slack_power / 2,
atol=1e-5)
assert np.isclose(net.res_gen.p_mw.at[0],
expected_slack_power / 2 + gen_p_disp,
atol=1e-5)
if do_output:
print("grid losses: %.6f" % -net.res_bus.p_mw.sum())
print("slack generator p results: %.6f %.6f" %
(net.res_ext_grid.p_mw.at[0], net.res_gen.p_mw.at[0]))
net.res_bus.vm_pu.plot()
def test_diagnostic_report():
net = nw.example_multivoltage()
net.line.loc[7, 'length_km'] = -1
net.gen.bus.at[0] = 0
net.load.p_kw.at[4] *= 1000
net.switch.closed.at[0] = 0
net.switch.closed.at[2] = 0
pp.create_switch(net, 41, 45, et='b')
net.line.r_ohm_per_km.at[1] = 0
net.load.p_kw.at[0] = -1
net.switch.closed.loc[37, 38] = False
net.line.x_ohm_per_km.loc[6] -= 1
net.line.from_bus.iloc[0] = 10000
pp.create_switch(net, 1, 2, et='b')
diag_results = pp.diagnostic(net)
diag_params = {
"overload_scaling_factor": 0.001,
"lines_min_length_km": 0,
"lines_min_z_ohm": 0,
"nom_voltage_tolerance": 0.3,
"numba_tolerance": 1e-5
}
diag_report = DiagnosticReports(net,
diag_results,
diag_params,
compact_report=False)
report_methods = {
"missing_bus_indeces": diag_report.report_missing_bus_indeces,
"disconnected_elements": diag_report.report_disconnected_elements,
"different_voltage_levels_connected":
diag_report.report_different_voltage_levels_connected,
"lines_with_impedance_close_to_zero":
diag_report.report_lines_with_impedance_close_to_zero,
"nominal_voltages_dont_match":
diag_report.report_nominal_voltages_dont_match,
"invalid_values": diag_report.report_invalid_values,
"overload": diag_report.report_overload,
"multiple_voltage_controlling_elements_per_bus":
diag_report.report_multiple_voltage_controlling_elements_per_bus,
"wrong_switch_configuration":
diag_report.report_wrong_switch_configuration,
"no_ext_grid": diag_report.report_no_ext_grid,
"wrong_reference_system": diag_report.report_wrong_reference_system,
"deviation_from_std_type": diag_report.report_deviation_from_std_type,
"numba_comparison": diag_report.report_numba_comparison,
"parallel_switches": diag_report.report_parallel_switches
}
for key in diag_results:
report_check = None
try:
report_methods[key]()
report_check = True
except:
report_check = False
assert report_check
diag_report = DiagnosticReports(net,
diag_results,
diag_params,
compact_report=True)
for key in diag_results:
report_check = None
try:
report_methods[key]()
report_check = True
except:
report_check = False
assert report_check
def test_net():
net = nw.example_multivoltage()
return net
# -*- coding: utf-8 -*-
# Copyright (c) 2016-2021 by University of Kassel and Fraunhofer Institute for Energy Economics
# and Energy System Technology (IEE), Kassel. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
import pandapower.networks as nw
import pandapower as pp
import pandapower.control as control
import os
net = nw.example_multivoltage()
control.DiscreteTapControl(net, 1, 1.02, 1.03)
pp.runpp(net, run_control=True)
pp.to_json(net, os.path.join("old_versions",
"example_%s.json" % pp.__version__))
def test_voltlvl_idx():
net = pn.example_multivoltage()
# add measurements
pp.create_measurement(net, "v", "bus", 1.03, 0.3,
net.bus.index[7]) # 380 kV
pp.create_measurement(net, "v", "bus", 1.03, 0.3,
net.bus.index[40]) # 10 kV
pp.create_measurement(net, "i", "trafo", 0.23, 0.03, net.trafo.index[-1],
"hv") # 10 kV
pp.create_measurement(net, "p", "trafo", 0.33, 0.03, net.trafo.index[0],
"lv") # 110 kV
pp.create_measurement(net, "i", "line", 0.23, 0.03, net.line.index[-1],
"to") # 0.4 kV
pp.create_measurement(net, "q", "line", 0.33, 0.03, net.line.index[0],
"from") # 110 kV
# checking voltlvl_idx()
hv_and_mv_buses = list(range(16, 45))
assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", 4)
assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", ["HV-MV"])
assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", [3, 5])
assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", ["HV", "MV"])
mv_loads = list(range(5, 13))
assert mv_loads == sb.voltlvl_idx(net, "load", "MV")
hvmv_trafo3ws = [0]
assert hvmv_trafo3ws == sb.voltlvl_idx(net,
"trafo3w",
"HV",
branch_bus="hv_bus")
assert hvmv_trafo3ws == sb.voltlvl_idx(net,
"trafo3w",
"MV",
branch_bus="mv_bus")
assert hvmv_trafo3ws == sb.voltlvl_idx(net,
"trafo3w",
"MV",
branch_bus="lv_bus")
ehvhv_trafos = [0]
assert ehvhv_trafos == sb.voltlvl_idx(net, "trafo", 1, branch_bus="hv_bus")
assert ehvhv_trafos == sb.voltlvl_idx(net, "trafo", 3, branch_bus="lv_bus")
ehvhv_and_hvmv_trafos = [0]
assert ehvhv_and_hvmv_trafos == sb.voltlvl_idx(net,
"trafo",
2,
branch_bus="hv_bus")
assert ehvhv_and_hvmv_trafos == sb.voltlvl_idx(net,
"trafo",
4,
branch_bus="lv_bus")
hvmv_trafos = []
assert hvmv_trafos == sb.voltlvl_idx(net, "trafo", 5, branch_bus="lv_bus")
mvlv_trafos = [1]
assert mvlv_trafos == sb.voltlvl_idx(net, "trafo", 5, branch_bus="hv_bus")
lv_loads = list(range(13, 25))
assert lv_loads == sb.voltlvl_idx(net, "load", 7)
m1 = sb.voltlvl_idx(net, "measurement", [1])
m3 = sb.voltlvl_idx(net, "measurement", 3)
m5 = sb.voltlvl_idx(net, "measurement", 5)
m7 = sb.voltlvl_idx(net, "measurement", 7)
assert m1 == [0]
assert m3 == [3, 5]
assert m5 == [1, 2]
assert m7 == [4]
assert len(net.measurement.index) == len(m1 + m3 + m5 + m7)
assert set(net.measurement.index) == set(m1) | set(m3) | set(m5) | set(m7)
def test_repl_to_line_with_switch():
"""
Same test as above, but this time in comparison to actual replacement
"""
net = nw.example_multivoltage()
pp.runpp(net)
for testindex in net.line.index:
if net.line.in_service.loc[testindex]:
# todo print weg
print("testing line " + str(testindex))
line = net.line.loc[testindex]
fbus = line.from_bus
tbus = line.to_bus
len = line.length_km
if "184-AL1/30-ST1A" in net.line.std_type.loc[testindex]:
std = "243-AL1/39-ST1A 110.0"
elif "NA2XS2Y" in net.line.std_type.loc[testindex]:
std = "NA2XS2Y 1x240 RM/25 6/10 kV"
elif "NAYY" in net.line.std_type.loc[testindex]:
std = "NAYY 4x150 SE"
elif " 15-AL1/3-ST1A" in net.line.std_type.loc[testindex]:
std = "24-AL1/4-ST1A 0.4"
# create an oos line at the same buses
REPL = pp.create_line(net, from_bus=fbus, to_bus=tbus, length_km=len, std_type=std)
for bus in fbus, tbus:
if bus in net.switch[(net.switch.closed == False) & (net.switch.element == testindex)].bus.values:
pp.create_switch(net, bus=bus, element=REPL, closed=False, et="l", type="LBS")
# calculate runpp with REPL
net.line.in_service[testindex] = False
net.line.in_service[REPL] = True
pp.runpp(net)
fbus_repl = net.res_bus.loc[fbus]
tbus_repl = net.res_bus.loc[tbus]
ploss_repl = (net.res_line.loc[REPL].p_from_mw - net.res_line.loc[REPL].p_to_mw )
qloss_repl =(net.res_line.loc[REPL].q_from_mvar - net.res_line.loc[REPL].q_to_mvar )
# get ne line impedances
new_idx = tb.repl_to_line(net, testindex, std, in_service=True)
# activate new idx line
net.line.in_service[REPL] = False
net.line.in_service[testindex] = True
net.line.in_service[new_idx] = True
pp.runpp(net)
# compare lf results
fbus_ne = net.res_bus.loc[fbus]
tbus_ne = net.res_bus.loc[tbus]
ploss_ne = (net.res_line.loc[testindex].p_from_mw - net.res_line.loc[testindex].p_to_mw)+\
(net.res_line.loc[new_idx].p_from_mw - net.res_line.loc[new_idx].p_to_mw)
qloss_ne = (net.res_line.loc[testindex].q_from_mvar - net.res_line.loc[testindex].q_to_mvar )+\
(net.res_line.loc[new_idx].q_from_mvar - net.res_line.loc[new_idx].q_to_mvar)
assert_series_equal(fbus_repl, fbus_ne, atol=1e-2)
assert_series_equal(tbus_repl, tbus_ne)
assert np.isclose(ploss_repl,ploss_ne, atol=1e-5)
assert np.isclose(qloss_repl,qloss_ne)
# and reset to unreinforced state again
net.line.in_service[testindex] = True
net.line.in_service[new_idx] = False
net.line.in_service[REPL] = False
