def test_shunt():
net = pp.create_empty_network()
b1 = pp.create_bus(net, 110)
b2 = pp.create_bus(net, 110)
pp.create_ext_grid(net, b1, s_sc_max_mva=300, rx_max=0.1)
# pp.create_shunt(net, b2, 25, 0, 6)
pp.create_line(net, b1, b2, std_type="305-AL1/39-ST1A 110.0", length_km=10)
sc.calc_sc(net, tk_s=2.5e-2)
def test_2bus_network_singel_oos_bus(net):
# -o---x---o
b1 = pp.create_bus(net, vn_kv=110)
net.bus.loc[5, "in_service"] = False
pp.create_line(net, from_bus=5, to_bus=b1, length_km=10.0, std_type="example_type")
pp.create_asymmetric_load(net, b1, p_a_mw=-5, q_a_mvar=5, p_b_mw=-1, q_b_mvar=1.5,
p_c_mw=-1, q_c_mvar=.5)
pp.add_zero_impedance_parameters(net)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
def test_opf_no_controllables_vs_pf():
""" Comparing the calculation results of PF and OPF in a simple network with non-controllable
elements """
# boundaries
vm_max = 1.3
vm_min = 0.9
max_line_loading_percent = 100
# create network
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
b2 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
pp.create_line(net,
b1,
b2,
length_km=5,
std_type="NAYY 4x50 SE",
max_loading_percent=max_line_loading_percent)
# test elements static
pp.create_ext_grid(net, b2)
pp.create_load(net, b1, p_mw=.0075, controllable=False)
pp.create_sgen(net,
b1,
p_mw=0.025,
controllable=False,
min_p_mw=0.01,
max_p_mw=0.025,
max_q_mvar=0.025,
min_q_mvar=-0.025)
# testing cost assignment (for non-controllable elements - see Gitlab Issue #27)
pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=3)
pp.create_poly_cost(net, 0, "load", cp1_eur_per_mw=-3)
pp.create_poly_cost(net, 0, "sgen", cp1_eur_per_mw=2)
# do calculations
pp.runopp(net)
assert net["OPF_converged"]
res_opf_line_loading = net.res_line.loading_percent
res_opf_bus_voltages = net.res_bus.vm_pu
pp.runpp(net)
assert net["converged"]
res_pf_line_loading = net.res_line.loading_percent
res_pf_bus_voltages = net.res_bus.vm_pu
# assert calculation behaviour
assert np.isclose(res_opf_line_loading, res_pf_line_loading).all()
assert np.isclose(res_opf_bus_voltages, res_pf_bus_voltages).all()
def test_volt_dep_load_at_inactive_bus():
# create empty net
net = pp.create_empty_network()
# create buses
bus1 = pp.create_bus(net, index=0, vn_kv=20., name="Bus 1")
bus2 = pp.create_bus(net, index=1, vn_kv=0.4, name="Bus 2")
bus3 = pp.create_bus(net,
index=3,
in_service=False,
vn_kv=0.4,
name="Bus 3")
bus4 = pp.create_bus(net, index=4, vn_kv=0.4, name="Bus 4")
bus4 = pp.create_bus(net, index=5, vn_kv=0.4, name="Bus 4")
# create bus elements
pp.create_ext_grid(net, bus=bus1, vm_pu=1.02, name="Grid Connection")
pp.create_load(net,
bus=4,
p_kw=100,
q_kvar=50,
name="Load3",
const_i_percent=100)
pp.create_load(net, bus=5, p_kw=100, q_kvar=50, name="Load4")
# create branch elements
trafo = pp.create_transformer(net,
hv_bus=bus1,
lv_bus=bus2,
std_type="0.4 MVA 20/0.4 kV",
name="Trafo")
line1 = pp.create_line(net,
from_bus=1,
to_bus=3,
length_km=0.1,
std_type="NAYY 4x50 SE",
name="Line")
line2 = pp.create_line(net,
from_bus=1,
to_bus=4,
length_km=0.1,
std_type="NAYY 4x50 SE",
name="Line")
line3 = pp.create_line(net,
from_bus=1,
to_bus=5,
length_km=0.1,
std_type="NAYY 4x50 SE",
name="Line")
pp.runpp(net)
assert not np.isnan(net.res_load.p_kw.at[1])
assert not np.isnan(net.res_bus.p_kw.at[5])
assert net.res_bus.p_kw.at[3] == 0
def test_2bus_network_isolated_net_part(net):
# -o---o o---o
b1 = pp.create_bus(net, vn_kv=110)
b2 = pp.create_bus(net, vn_kv=110)
pp.create_line(net, from_bus=b1, to_bus=b2, length_km=50.0, std_type="example_type")
pp.create_asymmetric_load(net, b2, p_a_mw=50, q_a_mvar=50, p_b_mw=10, q_b_mvar=15,
p_c_mw=10, q_c_mvar=5)
pp.add_zero_impedance_parameters(net)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
check_it(net)
def test_add_element_and_init_results():
net = simple_four_bus_system()
pp.runpp(net, init="flat")
pp.create_bus(net, vn_kv=20.)
pp.create_line(net,
from_bus=2,
to_bus=3,
length_km=1,
name="new line" + str(1),
std_type="NAYY 4x150 SE")
pp.runpp(net, init="results")
def test_1ph_with_switches():
net = pp.create_empty_network()
vc = "Yy"
l1, l2, _ = add_network(net, vc)
sc.calc_sc(net, fault="1ph", case="max")
pp.create_line(net, net.line.to_bus.at[l2], net.line.from_bus.at[l1], length_km=15,
std_type="unsymmetric_line_type", parallel=2.)
pp.add_zero_impedance_parameters(net)
pp.create_switch(net, bus=net.line.to_bus.at[l2], element=l2, et="l", closed=False)
sc.calc_sc(net, fault="1ph", case="max")
check_results(net, vc, [0.52209347338, 2.0620266652, 2.3255761263, 2.3066467489])
def feeder_network():
net = pp.create_empty_network()
current_bus = pp.create_bus(net, vn_kv=20.)
pp.create_ext_grid(net, current_bus)
for length in [12, 6, 8]:
new_bus = pp.create_bus(net, vn_kv=20.)
pp.create_line(net, current_bus, new_bus, length_km=length,
std_type="NA2XS2Y 1x185 RM/25 12/20 kV")
current_bus = new_bus
pp.create_line(net, current_bus, 0, length_km=5, std_type="NA2XS2Y 1x185 RM/25 12/20 kV")
return net
def test_ext_grid_and_gen_at_one_bus():
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=110)
b2 = pp.create_bus(net, vn_kv=110)
pp.create_ext_grid(net, b1, vm_pu=1.01)
pp.create_line(net, b1, b2, 1., std_type="305-AL1/39-ST1A 110.0")
pp.create_load(net, bus=b2, p_mw=3.5, q_mvar=1)
runpp_with_consistency_checks(net)
q = net.res_ext_grid.q_mvar.sum()
##create two gens at the slack bus
g1 = pp.create_gen(net, b1, vm_pu=1.01, p_mw=1)
g2 = pp.create_gen(net, b1, vm_pu=1.01, p_mw=1)
runpp_with_consistency_checks(net)
# all the reactive power previously provided by the ext_grid is now provided by the generators
assert np.isclose(net.res_ext_grid.q_mvar.values, 0)
assert np.isclose(net.res_gen.q_mvar.sum(), q)
# since no Q-limits were set, reactive power is distributed equally to both generators
assert np.isclose(net.res_gen.q_mvar.at[g1], net.res_gen.q_mvar.at[g2])
# set reactive power limits at the generators
net.gen["max_q_mvar"] = [0.1, 0.01]
net.gen["min_q_mvar"] = [-0.1, -0.01]
runpp_with_consistency_checks(net)
# g1 now has 10 times the reactive power of g2 in accordance with the different Q ranges
assert np.isclose(net.res_gen.q_mvar.at[g1], net.res_gen.q_mvar.at[g2] * 10)
# all the reactive power is still provided by the generators, because Q-lims are not enforced
assert np.allclose(net.res_ext_grid.q_mvar.values, [0])
assert np.isclose(net.res_gen.q_mvar.sum(), q)
# now enforce Q-lims
runpp_with_consistency_checks(net, enforce_q_lims=True)
# both generators are at there lower limit with regard to the reactive power
assert np.allclose(net.res_gen.q_mvar.values, net.gen.max_q_mvar.values)
# the total reactive power remains unchanged, but the rest of the power is now provided by the ext_grid
assert np.isclose(net.res_gen.q_mvar.sum() + net.res_ext_grid.q_mvar.sum(), q)
# second ext_grid at the slack bus
pp.create_ext_grid(net, b1, vm_pu=1.01)
runpp_with_consistency_checks(net, enforce_q_lims=False)
# gens still have the correct active power
assert np.allclose(net.gen.p_mw.values, net.res_gen.p_mw.values)
# slack active power is evenly distributed to both ext_grids
assert np.isclose(net.res_ext_grid.p_mw.values[0], net.res_ext_grid.p_mw.values[1])
# q limits at the ext_grids are not enforced
net.ext_grid["max_q_mvar"] = [0.1, 0.01]
net.ext_grid["min_q_mvar"] = [-0.1, -0.01]
runpp_with_consistency_checks(net, enforce_q_lims=True)
assert net.res_ext_grid.q_mvar.values[0] > net.ext_grid.max_q_mvar.values[0]
assert np.allclose(net.res_gen.q_mvar.values, net.gen.max_q_mvar.values)
def simple_four_bus_system():
"""
This function creates a simple four bus system with two radial low voltage nodes connected to \
a medium voltage slack bus. At both low voltage nodes the a load and a static generator is \
connected.
OUTPUT:
**net** - Returns the required four bus system
EXAMPLE:
import pandapower.networks as pn
net_simple_four_bus = pn.simple_four_bus_system()
"""
net = pp.create_empty_network()
busnr1 = pp.create_bus(net, name="bus1ref", vn_kv=10, geodata=[0, 0])
pp.create_ext_grid(net, busnr1)
busnr2 = pp.create_bus(net, name="bus2", vn_kv=.4, geodata=[0, -1])
pp.create_transformer(net,
busnr1,
busnr2,
name="transformer",
std_type="0.25 MVA 10/0.4 kV")
busnr3 = pp.create_bus(net, name="bus3", vn_kv=.4, geodata=[0, -2])
pp.create_line(net,
busnr2,
busnr3,
name="line1",
length_km=0.50000,
std_type="NAYY 4x50 SE")
busnr4 = pp.create_bus(net, name="bus4", vn_kv=.4, geodata=[0, -3])
pp.create_line(net,
busnr3,
busnr4,
name="line2",
length_km=0.50000,
std_type="NAYY 4x50 SE")
pp.create_load(net, busnr3, 0.030, 0.010, name="load1")
pp.create_load(net, busnr4, 0.030, 0.010, name="load2")
pp.create_sgen(net,
busnr3,
p_mw=0.020,
q_mvar=0.005,
name="pv1",
sn_mva=0.03)
pp.create_sgen(net,
busnr4,
p_mw=0.015,
q_mvar=0.002,
name="pv2",
sn_mva=0.02)
return net
def mixed_network():
net = pp.create_empty_network()
pp.create_buses(net, nr_buses=5, vn_kv=20.)
connections = [(0, 1), (1, 2), (2, 3), (2, 4)]
for fb, tb in connections:
pp.create_line(net,
fb,
tb,
length_km=1,
std_type="NA2XS2Y 1x185 RM/25 12/20 kV")
for b in [1, 4, 3]:
pp.create_ext_grid(net, b)
return net
def big_sgen_three_bus_example():
net = pp.create_empty_network()
b1 = pp.create_bus(net, 110)
b2 = pp.create_bus(net, 110)
b3 = pp.create_bus(net, 110)
pp.create_ext_grid(net, b1, s_sc_max_mva=100., s_sc_min_mva=80., rx_min=0.4, rx_max=0.4)
pp.create_line(net, b1, b2, std_type="305-AL1/39-ST1A 110.0" , length_km=20.)
pp.create_line(net, b2, b3, std_type="N2XS(FL)2Y 1x185 RM/35 64/110 kV" , length_km=15.)
net.line["endtemp_degree"] = 80
pp.create_sgen(net, b2, sn_mva=200., p_mw=0, k=1.2)
return net
def ring_network():
net = pp.create_empty_network()
b0 = pp.create_bus(net, 220)
b1 = pp.create_bus(net, 110)
b2 = pp.create_bus(net, 110)
b3 = pp.create_bus(net, 110)
pp.create_ext_grid(net, b0, s_sc_max_mva=100., s_sc_min_mva=80., rx_min=0.4, rx_max=0.4)
pp.create_transformer(net, b0, b1, "100 MVA 220/110 kV")
pp.create_line(net, b1, b2, std_type="305-AL1/39-ST1A 110.0" , length_km=20.)
l2 = pp.create_line(net, b2, b3, std_type="N2XS(FL)2Y 1x185 RM/35 64/110 kV" , length_km=15.)
pp.create_line(net, b3, b1, std_type="N2XS(FL)2Y 1x185 RM/35 64/110 kV" , length_km=10.)
pp.create_switch(net, b3, l2, closed=False, et="l")
return net
def test_graph_characteristics(feeder_network):
# adapt network
net = feeder_network
bus0 = pp.create_bus(net, vn_kv=20.0)
bus1 = pp.create_bus(net, vn_kv=20.0)
bus2 = pp.create_bus(net, vn_kv=20.0)
bus3 = pp.create_bus(net, vn_kv=20.0)
bus4 = pp.create_bus(net, vn_kv=20.0)
bus5 = pp.create_bus(net, vn_kv=20.0)
bus6 = pp.create_bus(net, vn_kv=20.0)
bus7 = pp.create_bus(net, vn_kv=20.0)
bus8 = pp.create_bus(net, vn_kv=20.0)
bus9 = pp.create_bus(net, vn_kv=20.0)
new_connections = [(3, bus0), (bus0, bus1), (bus0, bus2), (1, bus3),
(2, bus4), (bus3, bus4), (bus4, bus5), (bus4, bus6),
(bus5, bus6), (2, bus7), (bus7, bus8), (bus8, bus9),
(bus9, bus7)]
for fb, tb in new_connections:
pp.create_line(net,
fb,
tb,
length_km=1.0,
std_type="NA2XS2Y 1x185 RM/25 12/20 kV")
# get characteristics
mg = top.create_nxgraph(net, respect_switches=False)
characteristics = [
"bridges", "articulation_points", "connected", "stub_buses",
"required_bridges", "notn1_areas"
]
char_dict = top.find_graph_characteristics(mg, net.ext_grid.bus,
characteristics)
bridges = char_dict["bridges"]
articulation_points = char_dict["articulation_points"]
connected = char_dict["connected"]
stub_buses = char_dict["stub_buses"]
required_bridges = char_dict["required_bridges"]
notn1_areas = char_dict["notn1_areas"]
assert bridges == {(3, 4), (4, 5), (4, 6), (2, 11)}
assert articulation_points == {8, 3, 4, 2, 11}
assert connected == {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
assert stub_buses == {4, 5, 6, 11, 12, 13}
assert required_bridges == {
4: [(3, 4)],
5: [(3, 4), (4, 5)],
6: [(3, 4), (4, 6)],
11: [(2, 11)],
12: [(2, 11)],
13: [(2, 11)]
}
assert notn1_areas == {8: {9, 10}, 3: {4, 5, 6}, 2: {11, 12, 13}}
def test_3ph_two_bus_line_powerfactory():
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=0.4)
b2 = pp.create_bus(net, vn_kv=0.4)
pp.create_ext_grid(net, b1, vm_pu=1.0, s_sc_max_mva=10, rx_max=0.1)
net.ext_grid["x0x_max"] = 1.
net.ext_grid["r0x0_max"] = 0.1
pp.create_std_type(net, {"r_ohm_per_km": 0.1013, "x_ohm_per_km": 0.06911504,
"c_nf_per_km": 690, "g_us_per_km": 0, "max_i_ka": 0.44,
"c0_nf_per_km": 312.4, "r0_ohm_per_km": 0.4053,
"x0_ohm_per_km": 0.2764602}, "N2XRY 3x185sm 0.6/1kV")
pp.create_line(net, b1, b2, 0.4, std_type="N2XRY 3x185sm 0.6/1kV")
pp.add_zero_impedance_parameters(net)
pp.create_load(net, b2, p_mw=0.010, q_mvar=0.010)
pp.create_asymmetric_load(net, b2, p_a_mw=0.020, q_a_mvar=0.010, p_b_mw=0.015, q_b_mvar=0.005, p_c_mw=0.025,
q_c_mvar=0.010)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
bus_pp = np.abs(net.res_bus_3ph[['vm_a_pu', 'vm_b_pu', 'vm_c_pu']].values)
bus_pf = np.abs(np.array([[0.99939853552, 1.0013885141, 0.99921580141],
[0.97401782343, 0.98945593737, 0.96329605983]]))
assert np.max(np.abs(bus_pp-bus_pf)) < 4e-6
line_pp = np.abs(net.res_line_3ph[
['i_a_from_ka', 'i_b_from_ka', 'i_c_from_ka',
'i_a_to_ka', 'i_b_to_ka', 'i_c_to_ka',
'p_a_from_mw', 'p_b_from_mw', 'p_c_from_mw',
'q_a_from_mvar', 'q_b_from_mvar', 'q_c_from_mvar',
'p_a_to_mw', 'p_b_to_mw', 'p_c_to_mw',
'q_a_to_mvar', 'q_b_to_mvar', 'q_c_to_mvar']].values)
line_pf = np.abs(np.array(
[[0.11946088987 , 0.08812337783 , 0.14074226065 ,
0.1194708224 , 0.088131567331 , 0.14075063601 ,
0.023810539354 , 0.01855791658 , 0.029375192747 ,
0.013901720672 , 0.008421814704 , 0.013852398586 ,
-0.023333142958 , -0.018333405987 , -0.028331643666 ,
-0.013332756527 , -0.008333413919 , -0.013332422725 ]]))
assert np.max(np.abs(line_pp - line_pf)) < 1e-5
line_load_pp = np.abs(net.res_line_3ph[
['loading_a_percent', 'loading_b_percent', 'loading_c_percent',
'loading_percent']].values)
line_load_pf = np.abs(np.array(
[[27.1525 , 20.0299 , 31.98878 ,
31.98878]]))
assert np.max(np.abs(line_load_pp - line_load_pf)) < 1e-2
def test_close_to_gen_simple():
# from pandapower.shortcircuit import calc_sc
# vars = {name: getattr(calc_sc, name) for name in
# dir(calc_sc) if not name.startswith('__')}
# globals().update(vars)
# del vars, calc_sc
# WIP
net = pp.create_empty_network()
b1, b2, b3, b4, b5 = pp.create_buses(net, 5, 20)
# skss = np.sqrt(3) * 400 * 40 # we assume 40 kA sc current in the 400-kV EHV grid
# pp.create_ext_grid(net, b1, s_sc_max_mva=skss, s_sc_min_mva=0.8 * skss, rx_min=0.2, rx_max=0.4)
pp.create_gen(net,
b3,
vn_kv=20,
xdss_pu=0.2,
rdss_pu=0.2 * 0.07,
cos_phi=0.8,
p_mw=5,
sn_mva=5)
pp.create_gen(net,
b5,
vn_kv=20,
xdss_pu=0.2,
rdss_pu=0.2 * 0.07,
cos_phi=0.8,
p_mw=10,
sn_mva=10)
pp.create_line(net, b1, b2, std_type="305-AL1/39-ST1A 110.0", length_km=10)
pp.create_line(net, b2, b3, std_type="305-AL1/39-ST1A 110.0", length_km=10)
pp.create_line(net, b3, b4, std_type="305-AL1/39-ST1A 110.0", length_km=50)
pp.create_line(net, b4, b5, std_type="305-AL1/39-ST1A 110.0", length_km=10)
# sc.calc_single_sc(net, b5)
sc.calc_sc(net, tk_s=5e-2)
def panda_four_load_branch():
"""
This function creates a simple six bus system with four radial low voltage nodes connected to \
a medium valtage slack bus. At every low voltage node the same load is connected.
OUTPUT:
**net** - Returns the required four load system
EXAMPLE:
import pandapower.networks as pn
net_four_load = pn.panda_four_load_branch()
"""
pd_net = pp.create_empty_network()
busnr1 = pp.create_bus(pd_net, name="bus1", vn_kv=10.)
busnr2 = pp.create_bus(pd_net, name="bus2", vn_kv=.4)
busnr3 = pp.create_bus(pd_net, name="bus3", vn_kv=.4)
busnr4 = pp.create_bus(pd_net, name="bus4", vn_kv=.4)
busnr5 = pp.create_bus(pd_net, name="bus5", vn_kv=.4)
busnr6 = pp.create_bus(pd_net, name="bus6", vn_kv=.4)
pp.create_ext_grid(pd_net, busnr1)
pp.create_transformer(pd_net,
busnr1,
busnr2,
std_type="0.25 MVA 10/0.4 kV")
pp.create_line(pd_net,
busnr2,
busnr3,
name="line1",
length_km=0.05,
std_type="NAYY 4x120 SE")
pp.create_line(pd_net,
busnr3,
busnr4,
name="line2",
length_km=0.05,
std_type="NAYY 4x120 SE")
pp.create_line(pd_net,
busnr4,
busnr5,
name="line3",
length_km=0.05,
std_type="NAYY 4x120 SE")
pp.create_line(pd_net,
busnr5,
busnr6,
name="line4",
length_km=0.05,
std_type="NAYY 4x120 SE")
pp.create_load(pd_net, busnr3, 30, 10)
pp.create_load(pd_net, busnr4, 30, 10)
pp.create_load(pd_net, busnr5, 30, 10)
pp.create_load(pd_net, busnr6, 30, 10)
return pd_net
def _net_for_testing():
net = pp.create_empty_network()
pp.create_buses(net, 17, 10, name=["Bus %i" % i for i in range(17)])
pp.create_buses(net, 2, 0.4, name=["Bus %i" % i for i in range(17, 19)])
pp.create_switch(net, 0, 1, "b", closed=True)
pp.create_switch(net, 2, 3, "b", closed=False)
pp.create_switch(net, 4, 5, "b", closed=False)
pp.create_switch(net, 5, 6, "b", closed=True)
pp.create_line(net, 7, 8, 1, 'NAYY 4x50 SE', name="Line 0")
pp.create_switch(net, 7, 0, "l", closed=True)
pp.create_switch(net, 8, 0, "l", closed=True)
pp.create_line(net, 9, 10, 1, 'NAYY 4x50 SE', name="Line 1")
pp.create_switch(net, 9, 1, "l", closed=False)
pp.create_switch(net, 10, 1, "l", closed=True)
pp.create_line(net, 11, 12, 1, 'NAYY 4x50 SE', name="Line 2")
pp.create_switch(net, 11, 2, "l", closed=True)
pp.create_switch(net, 12, 2, "l", closed=False)
pp.create_line(net, 13, 14, 1, 'NAYY 4x50 SE', name="Line 3")
pp.create_switch(net, 13, 3, "l", closed=False)
pp.create_switch(net, 14, 3, "l", closed=False)
pp.create_transformer(net, 15, 17, std_type="0.4 MVA 10/0.4 kV", name="Trafo 0")
pp.create_switch(net, 15, 0, "t", closed=True)
pp.create_switch(net, 17, 0, "t", closed=False)
pp.create_transformer(net, 16, 18, std_type="0.4 MVA 10/0.4 kV", name="Trafo 1")
pp.create_switch(net, 16, 1, "t", closed=False)
pp.create_switch(net, 18, 1, "t", closed=True)
return net
def tnep_grid():
net = pp.create_empty_network()
min_vm_pu = 0.95
max_vm_pu = 1.05
# create buses
bus1 = pp.create_bus(net, vn_kv=110., geodata=(5, 9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
bus2 = pp.create_bus(net, vn_kv=110., geodata=(6, 10), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
bus3 = pp.create_bus(net, vn_kv=110., geodata=(10, 9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
bus4 = pp.create_bus(net, vn_kv=110., geodata=(8, 8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
# create 110 kV lines
pp.create_line(net, bus1, bus2, length_km=70., std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net, bus1, bus3, length_km=50., std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net, bus1, bus4, length_km=100., std_type='149-AL1/24-ST1A 110.0')
# create loads
pp.create_load(net, bus2, p_mw=60)
pp.create_load(net, bus3, p_mw=70)
pp.create_load(net, bus4, p_mw=50)
# create generators
g1 = pp.create_gen(net, bus1, p_mw=9.513270, min_p_mw=0, max_p_mw=200, vm_pu=1.01, slack=True)
pp.create_poly_cost(net, g1, 'gen', cp1_eur_per_mw=1)
g2 = pp.create_gen(net, bus2, p_mw=78.403291, min_p_mw=0, max_p_mw=200, vm_pu=1.01)
pp.create_poly_cost(net, g2, 'gen', cp1_eur_per_mw=3)
g3 = pp.create_gen(net, bus3, p_mw=92.375601, min_p_mw=0, max_p_mw=200, vm_pu=1.01)
pp.create_poly_cost(net, g3, 'gen', cp1_eur_per_mw=3)
net.line["max_loading_percent"] = 20
# possible new lines (set out of service in line DataFrame)
l1 = pp.create_line(net, bus1, bus4, 10., std_type="305-AL1/39-ST1A 110.0", name="new_line1",
max_loading_percent=20., in_service=False)
l2 = pp.create_line(net, bus2, bus4, 20., std_type="149-AL1/24-ST1A 110.0", name="new_line2",
max_loading_percent=20., in_service=False)
l3 = pp.create_line(net, bus3, bus4, 30., std_type='149-AL1/24-ST1A 110.0', name="new_line3",
max_loading_percent=20., in_service=False)
l4 = pp.create_line(net, bus3, bus4, 40., std_type='149-AL1/24-ST1A 110.0', name="new_line4",
max_loading_percent=20., in_service=False)
new_line_index = [l1, l2, l3, l4]
construction_costs = [10., 20., 30., 45.]
# create new line dataframe
init_ne_line(net, new_line_index, construction_costs)
return net
def __init__(self):
# create empty net
net = pp.create_empty_network()
# create buses
b1 = pp.create_bus(net, vn_kv=20., name="Bus 1")
b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2")
b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3")
# create bus elements
pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection")
pp.create_load(net, bus=b3, p_mw=0.1, q_mvar=0.05, name="Load")
# create branch elements
tid = pp.create_transformer(net, hv_bus=b1, lv_bus=b2, std_type="0.4 MVA 20/0.4 kV", name="Trafo")
pp.create_line(net, from_bus=b2, to_bus=b3, length_km=0.1, name="Line", std_type="NAYY 4x50 SE")
self.pp_network: pp.pandapowerNet = net
def test_bus_bus_switch_at_eg():
net = pp.create_empty_network()
b1 = pp.create_bus(net, name="bus1", vn_kv=.4)
b2 = pp.create_bus(net, name="bus2", vn_kv=.4)
b3 = pp.create_bus(net, name="bus3", vn_kv=.4)
pp.create_ext_grid(net, b1)
pp.create_switch(net, b1, et="b", element=1)
pp.create_line(net, b2, b3, 1, name="line1", std_type="NAYY 4x150 SE")
pp.create_load(net, b3, p_kw=10, q_kvar=0, name="load1")
runpp_with_consistency_checks(net)
def meshed_network():
net = pp.create_empty_network("7bus_system")
# ext grid
b = []
b.append(pp.create_bus(net, vn_kv=380., name="exi", geodata=(0, 0)))
pp.create_ext_grid(net, b[0], name="exi")
# create 110kV buses
for i in range(1, 7):
b.append(
pp.create_bus(net, vn_kv=110., name="bus" + str(i),
geodata=(0, 0)))
# connect buses b1 to b6 with overhead lines
for i in range(1, 6):
l = pp.create_line(net,
b[i],
b[i + 1],
length_km=10. * i * 2.,
std_type="149-AL1/24-ST1A 110.0",
name="line" + str(i),
index=i + 2)
pp.create_switch(net,
b[i],
l,
et="l",
name="bl_switch_" + str(i),
index=i + 3)
# create trafo
pp.create_transformer(net,
hv_bus=b[0],
lv_bus=b[1],
std_type="160 MVA 380/110 kV",
name="trafo")
# create some more lines between b6-b1 and b1-b4
pp.create_line(net,
b[1],
b[4],
length_km=100.,
std_type="149-AL1/24-ST1A 110.0",
name="line6")
pp.create_line(net,
b[6],
b[1],
length_km=100.,
std_type="149-AL1/24-ST1A 110.0",
name="line7")
return net
def test_create_replacement_switch_for_branch():
net = pp.create_empty_network()
bus0 = pp.create_bus(net, vn_kv=0.4)
bus1 = pp.create_bus(net, vn_kv=0.4)
bus2 = pp.create_bus(net, vn_kv=0.4)
bus3 = pp.create_bus(net, vn_kv=0.4)
pp.create_ext_grid(net, bus0, vm_pu=0.4)
line0 = pp.create_line(net,
bus0,
bus1,
length_km=1,
std_type="NAYY 4x50 SE")
line1 = pp.create_line(net,
bus2,
bus3,
length_km=1,
std_type="NAYY 4x50 SE")
impedance0 = pp.create_impedance(net, bus1, bus2, 0.01, 0.01, sn_kva=1e5)
impedance1 = pp.create_impedance(net, bus1, bus2, 0.01, 0.01, sn_kva=1e5)
pp.create_load(net, bus2, 1)
pp.runpp(net)
# look that the switch is created properly
tb.create_replacement_switch_for_branch(net, 'line', line0)
tb.create_replacement_switch_for_branch(net, 'impedance', impedance0)
net.line.in_service.at[line0] = False
net.impedance.in_service.at[impedance0] = False
assert 'REPLACEMENT_line_0' in net.switch.name.values
assert 'REPLACEMENT_impedance_0' in net.switch.name.values
assert net.switch.closed.at[0]
assert net.switch.closed.at[1]
pp.runpp(net)
# look that the switch is created with the correct closed status
net.line.in_service.at[line1] = False
net.impedance.in_service.at[impedance1] = False
tb.create_replacement_switch_for_branch(net, 'line', line1)
tb.create_replacement_switch_for_branch(net, 'impedance', impedance1)
assert 'REPLACEMENT_line_1' in net.switch.name.values
assert 'REPLACEMENT_impedance_1' in net.switch.name.values
assert ~net.switch.closed.at[2]
assert ~net.switch.closed.at[3]
def add_aclines(network, df=None, file=None):
"""
Add AC-lines to the specified network. Pass either a DataFrame or a pathstring to a csv-file.
Parameters
----------
network : pandapowerNet
PandaPower network representation.
df : DataFrame
DataFrame with bus characteristics.
file : str
Path to csv-file with AC-line characteristics.
Return
------
net : pandapowerNet
PandaPower network representation with added AC-lines.
"""
# copy network
net = copy.deepcopy(network)
# load AC lines
linesAC = check_arguments(df, file)
# create dictonairy of busnames and busindices
busdict = dict(zip(net.bus.name, net.bus.index))
# parameter lines
parameter_lines = linesAC[linesAC.std_type.isna() == True]
for index, line in parameter_lines.iterrows():
pp.create_line_from_parameters(net, name=line['name'], from_bus=busdict[line.from_bus],
to_bus=busdict[line.to_bus], length_km=line.length_km,
r_ohm_per_km=line.r_ohm_per_km, x_ohm_per_km=line.x_ohm_per_km,
c_nf_per_km=line.c_nf_per_km, max_i_ka=line.max_i_ka,
parallel=line.parallel, type=line.type, in_service=line.in_service,
max_loading_percent=line.max_loading_percent)
# default lines
default_lines = linesAC[linesAC.std_type.isna() == False]
for index, line in default_lines.iterrows():
pp.create_line(net, name=line['name'], from_bus=busdict[line.from_bus],
to_bus=busdict[line.to_bus], length_km=line.length_km, std_type=line.std_type,
parallel=line.parallel, in_service=line.in_service,
max_loading_percent=line.max_loading_percent)
return net
def ring_network():
net = pp.create_empty_network()
b1 = pp.create_bus(net, 220)
b2 = pp.create_bus(net, 110)
b3 = pp.create_bus(net, 110)
b4 = pp.create_bus(net, 110)
pp.create_ext_grid(net, b1, s_sc_max_mva=100., s_sc_min_mva=80., rx_min=0.20, rx_max=0.35)
pp.create_transformer(net, b1, b2, "100 MVA 220/110 kV")
pp.create_line(net, b2, b3, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV", length_km=15.)
l2 = pp.create_line(net, b3, b4, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV", length_km=12.)
pp.create_line(net, b4, b2, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV", length_km=10.)
pp.create_switch(net, b4, l2, closed=False, et="l")
return net
def test_bsfw_algorithm_with_branch_loops():
net = example_simple()
pp.create_line(net, 0, 6, length_km=2.5,
std_type="NA2XS2Y 1x240 RM/25 12/20 kV", name="Line meshed")
net.switch.loc[:, "closed"] = True
pp.runpp(net)
vm_nr = net.res_bus.vm_pu
va_nr = net.res_bus.va_degree
pp.runpp(net, algorithm='bfsw')
vm_alg = net.res_bus.vm_pu
va_alg = net.res_bus.va_degree
assert np.allclose(vm_nr, vm_alg)
assert np.allclose(va_nr, va_alg)
def test_create_line_alpha_temperature():
net = pp.create_empty_network()
b = pp.create_buses(net, 5, 110)
l1 = pp.create_line(net, 0, 1, 10, "48-AL1/8-ST1A 10.0")
l2 = pp.create_line(net, 1, 2, 10, "48-AL1/8-ST1A 10.0", alpha=4.03e-3, temperature_degree_celsius=80)
l3 = pp.create_line(net, 2, 3, 10, "48-AL1/8-ST1A 10.0")
l4 = pp.create_line_from_parameters(net, 3, 4, 10, 1, 1, 1, 100)
l5 = pp.create_line_from_parameters(net, 3, 4, 10, 1, 1, 1, 100, alpha=4.03e-3)
assert 'alpha' in net.line.columns
assert all(net.line.loc[[l2, l3, l5], 'alpha'] == 4.03e-3)
assert all(net.line.loc[[l1, l4], 'alpha'].isnull())
assert net.line.loc[l2, 'temperature_degree_celsius'] == 80
assert all(net.line.loc[[l1, l3, l4, l5], 'temperature_degree_celsius'].isnull())
def test_0gen_2ext_grid_decoupled():
net = create_test_network2()
net.gen = net.gen.drop(0)
net.shunt.q_kvar *= -1
pp.create_ext_grid(net, 1)
net.ext_grid.in_service.at[1] = False
pp.create_ext_grid(net, 3)
net.ext_grid.in_service.at[2] = False
auxbus = pp.create_bus(net, name="bus1", vn_kv=10.)
net.trafo.shift_degree = 150
pp.create_std_type(net, {
"type": "cs",
"r_ohm_per_km": 0.876,
"q_mm2": 35.0,
"endtmp_deg": 160.0,
"c_nf_per_km": 260.0,
"max_i_ka": 0.123,
"x_ohm_per_km": 0.1159876
},
name="NAYSEY 3x35rm/16 6/10kV",
element="line")
pp.create_line(
net,
0,
auxbus,
1,
name="line_to_decoupled_grid",
std_type="NAYSEY 3x35rm/16 6/10kV") #NAYSEY 3x35rm/16 6/10kV
pp.create_ext_grid(net, auxbus)
pp.create_switch(net, auxbus, 2, et="l", closed=0, type="LS")
pp.runpp(net, init='dc', calculate_voltage_angles=True)
assert np.allclose(
net.res_bus.p_kw.values,
[-133.158732, 30.000000, 0.000000, 100.000000, 0.000000])
assert np.allclose(
net.res_bus.q_kvar.values,
[39.5843982697, 2.000000, -28.5636406913, 0.000000, 0.000000])
assert np.allclose(
net.res_bus.va_degree.values,
[0.000000, -155.752225311, -153.669395244, -0.0225931152895, 0.0])
assert np.allclose(net.res_bus.vm_pu.values,
[1.000000, 0.930961, 0.975764, 0.998865, 1.0])
assert np.allclose(net.res_ext_grid.p_kw.values,
[-133.158732, 0.000000, 0.000000, -0.000000])
assert np.allclose(net.res_ext_grid.q_kvar,
[39.5843982697, 0.000000, 0.000000, -0.000000])
def simple_test_net():
net = pp.create_empty_network()
pp.set_user_pf_options(net, init='dc', calculate_voltage_angles=True)
b0 = pp.create_bus(net, 110)
b1 = pp.create_bus(net, 110)
b2 = pp.create_bus(net, 20)
b3 = pp.create_bus(net, 20)
b4 = pp.create_bus(net, 6)
pp.create_ext_grid(net, b0)
pp.create_line(net, b0, b1, 10, "149-AL1/24-ST1A 110.0")
pp.create_transformer(net, b1, b2, "25 MVA 110/20 kV", name='tr1')
pp.create_transformer3w_from_parameters(net,
b1,
b3,
b4,
110,
20,
6,
1e2,
1e2,
1e1,
3,
2,
2,
1,
1,
1,
100,
1,
60,
30,
'hv',
tap_step_percent=1.5,
tap_step_degree=0,
tap_pos=0,
tap_neutral=0,
tap_max=10,
tap_min=-10,
name='tr2')
pp.create_load(net, b2, 1.5e1, 1, name='trafo1')
pp.create_load(net, b3, 3e1, 1.5, name='trafo2_mv')
pp.create_load(net, b4, 2, -0.15, name='trafo2_lv')
return net
def test_check_existing_measurements():
np.random.seed(2017)
net = pp.create_empty_network()
pp.create_bus(net, 10.)
pp.create_bus(net, 10.)
pp.create_line(net, 0, 1, 0.5, std_type="149-AL1/24-ST1A 10.0")
m1 = pp.create_measurement(net, "v", "bus", 1.006, .004, 0)
m2 = pp.create_measurement(net, "v", "bus", 1.006, .004, 0)
assert m1 == m2
assert len(net.measurement) == 1
m3 = pp.create_measurement(net,
"v",
"bus",
1.006,
.004,
0,
check_existing=False)
assert m3 != m2
assert len(net.measurement) == 2
m4 = pp.create_measurement(net,
"p",
"line",
-0.0011e3,
0.01e3,
bus=0,
element=0,
check_existing=True)
m5 = pp.create_measurement(net,
"p",
"line",
-0.0011e3,
0.01e3,
bus=0,
element=0,
check_existing=True)
assert m4 == m5
m6 = pp.create_measurement(net,
"p",
"line",
-0.0011e3,
0.01e3,
bus=0,
element=0,
check_existing=False)
assert m5 != m6
def test_pandapower_case():
#more complicated examples like
#net = pandapower.networks.example_simple()
#can be used once the import of e.g. switches is perfected
#create empty net
net = pp.create_empty_network()
#create buses
b1 = pp.create_bus(net, vn_kv=20., name="Bus 1")
b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2")
b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3")
#create bus elements
pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection")
pp.create_load(net, bus=b3, p_kw=100, q_kvar=50, name="Load")
#create branch elements
tid = pp.create_transformer(net, hv_bus=b1, lv_bus=b2, std_type="0.4 MVA 20/0.4 kV",
name="Trafo")
pp.create_line(net, from_bus=b2, to_bus=b3, length_km=0.1, name="Line",
std_type="NAYY 4x50 SE")
#because of phase angles, need to init with DC
pp.runpp(net,calculate_voltage_angles=True,init="dc")
n = pypsa.Network()
n.import_from_pandapower_net(net)
#seed PF with LPF solution because of phase angle jumps
n.lpf()
n.pf(use_seed=True)
#use same index for everything
net.res_bus.index = net.bus.name.values
net.res_line.index = net.line.name.values
#compare bus angles
np.testing.assert_array_almost_equal(n.buses_t.v_ang.loc["now"]*180/np.pi,net.res_bus.va_degree)
#compare bus voltage magnitudes
np.testing.assert_array_almost_equal(n.buses_t.v_mag_pu.loc["now"],net.res_bus.vm_pu)
#compare bus active power (NB: pandapower uses load signs)
np.testing.assert_array_almost_equal(n.buses_t.p.loc["now"],-net.res_bus.p_kw/1e3)
#compare bus active power (NB: pandapower uses load signs)
np.testing.assert_array_almost_equal(n.buses_t.q.loc["now"],-net.res_bus.q_kvar/1e3)
#compare branch flows
np.testing.assert_array_almost_equal(n.lines_t.p0.loc["now"],net.res_line.p_from_kw/1e3)
np.testing.assert_array_almost_equal(n.lines_t.p1.loc["now"],net.res_line.p_to_kw/1e3)
np.testing.assert_array_almost_equal(n.lines_t.q0.loc["now"],net.res_line.q_from_kvar/1e3)
np.testing.assert_array_almost_equal(n.lines_t.q1.loc["now"],net.res_line.q_to_kvar/1e3)
np.testing.assert_array_almost_equal(n.transformers_t.p0.loc["now"],net.res_trafo.p_hv_kw/1e3)
np.testing.assert_array_almost_equal(n.transformers_t.p1.loc["now"],net.res_trafo.p_lv_kw/1e3)
np.testing.assert_array_almost_equal(n.transformers_t.q0.loc["now"],net.res_trafo.q_hv_kvar/1e3)
np.testing.assert_array_almost_equal(n.transformers_t.q1.loc["now"],net.res_trafo.q_lv_kvar/1e3)
