def test_overloaded_lines():
net = pp.create_empty_network()
bus0 = pp.create_bus(net, vn_kv=.4)
bus1 = pp.create_bus(net, vn_kv=.4)
ext_grid0 = pp.create_ext_grid(net, bus0, vm_pu=4)
line0 = pp.create_line(net,
bus0,
bus1,
length_km=1,
std_type="NAYY 4x50 SE")
line1 = pp.create_line(net,
bus0,
bus1,
length_km=1,
std_type="NA2XS2Y 1x95 RM/25 12/20 kV")
line2 = pp.create_line(net,
bus0,
bus1,
length_km=1,
std_type="15-AL1/3-ST1A 0.4")
line3 = pp.create_line(net,
bus0,
bus1,
length_km=10,
std_type="149-AL1/24-ST1A 10.0")
pp.runpp(net)
# test the overloaded lines by default value of max_load=100
overloaded_lines = tb.overloaded_lines(net, max_load=100)
assert set(overloaded_lines) == set([line0, line1, line2])
# test the overloaded lines by a self defined value of max_load=50
overloaded_lines = tb.overloaded_lines(net, max_load=50)
assert set(overloaded_lines) == set([line0, line1, line2, line3])
def test_get_costs():
""" Testing a very simple network for the resulting cost value
constraints with OPF """
# boundaries:
vm_max = 1.05
vm_min = 0.95
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_gen(net,
1,
p_mw=0.1,
controllable=True,
min_p_mw=0.05,
max_p_mw=0.15,
max_q_mvar=0.05,
min_q_mvar=-0.05)
pp.create_ext_grid(net, 0)
pp.create_load(net, 1, p_mw=0.02, controllable=False)
pp.create_line_from_parameters(net,
0,
1,
50,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
pp.create_pwl_cost(net, 0, "gen", [[0, 150, 2]])
# run OPF
pp.runopp(net)
assert net["OPF_converged"]
assert net.res_gen.p_mw.values[0] - net.gen.min_p_mw.values[0] < 1e-2
assert np.isclose(net.res_cost, 2 * net.res_gen.p_mw.values[0])
def panda_four_load_branch():
"""
This function creates a simple six bus system with four radial low voltage nodes connected to \
a medium voltage 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()
"""
net = pp.create_empty_network()
busnr1 = pp.create_bus(net, name="bus1", vn_kv=10., geodata=[0, 0])
busnr2 = pp.create_bus(net, name="bus2", vn_kv=.4, geodata=[0, -1])
busnr3 = pp.create_bus(net, name="bus3", vn_kv=.4, geodata=[0, -2])
busnr4 = pp.create_bus(net, name="bus4", vn_kv=.4, geodata=[0, -3])
busnr5 = pp.create_bus(net, name="bus5", vn_kv=.4, geodata=[0, -4])
busnr6 = pp.create_bus(net, name="bus6", vn_kv=.4, geodata=[0, -5])
pp.create_ext_grid(net, busnr1)
pp.create_transformer(net, busnr1, busnr2, std_type="0.25 MVA 10/0.4 kV")
pp.create_line(net, busnr2, busnr3, name="line1", length_km=0.05,
std_type="NAYY 4x120 SE")
pp.create_line(net, busnr3, busnr4, name="line2", length_km=0.05,
std_type="NAYY 4x120 SE")
pp.create_line(net, busnr4, busnr5, name="line3", length_km=0.05,
std_type="NAYY 4x120 SE")
pp.create_line(net, busnr5, busnr6, name="line4", length_km=0.05,
std_type="NAYY 4x120 SE")
pp.create_load(net, busnr3, 0.030, 0.010)
pp.create_load(net, busnr4, 0.030, 0.010)
pp.create_load(net, busnr5, 0.030, 0.010)
pp.create_load(net, busnr6, 0.030, 0.010)
return net
def test_cost_piecewise_linear_sgen_very_unsteady_slopes():
""" Testing a very simple network for the resulting cost value
constraints with OPF """
# boundaries:
vm_max = 1.5
vm_min = 0.5
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_sgen(net,
1,
p_mw=0.10,
controllable=True,
min_p_mw=0,
max_p_mw=1.50,
max_q_mvar=0.05,
min_q_mvar=-0.05)
pp.create_ext_grid(net, 0)
pp.create_load(net, 1, p_mw=0.02, controllable=False)
pp.create_line_from_parameters(net,
0,
1,
50,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
pp.create_pwl_cost(net, 0, "sgen", [[0, 0.75, -1], [0.75, 1500, 2]])
# run OPF
pp.runopp(net)
assert net["OPF_converged"]
assert np.isclose(net.res_sgen.p_mw.values[0], .75, rtol=1e-2)
assert np.isclose(net.res_sgen.p_mw.values[0], -net.res_cost, rtol=1e-2)
def test_ext_grid_gen_order_in_ppc():
net=pp.create_empty_network()
for b in range(6):
pp.create_bus(net,vn_kv=1., name=b)
for l_bus in range(0,5,2):
pp.create_line(net, from_bus=l_bus, to_bus=l_bus+1, length_km=1, std_type="48-AL1/8-ST1A 10.0")
for slack_bus in [0,2,5]:
pp.create_ext_grid(net, bus=slack_bus, vm_pu=1.)
for gen_bus in [ 0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5]:
pp.create_gen(net, bus=gen_bus, p_mw=1, vm_pu=1.)
pp.rundcpp(net)
assert all(net.res_gen.p_mw==net.gen.p_mw)
assert all(net.res_ext_grid.p_mw<0)
pp.runpp(net)
assert all(net.res_gen.p_mw==net.gen.p_mw)
assert all(net.res_ext_grid.p_mw<0)
def test_dc_with_ext_grid_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_ext_grid(net, b2, vm_pu=1.01)
pp.create_dcline(net,
from_bus=b1,
to_bus=b2,
p_mw=10,
loss_percent=0,
loss_mw=0,
vm_from_pu=1.01,
vm_to_pu=1.01)
pp.create_sgen(net, b1, p_mw=10)
pp.create_load(net, b2, p_mw=10)
runpp_with_consistency_checks(net)
assert np.allclose(net.res_ext_grid.p_mw.values, [0, 0])
def test_runpp_init_auxiliary_buses():
net = pp.create_empty_network()
b1, b2, l1 = add_grid_connection(net, vn_kv=110.)
b3 = pp.create_bus(net, vn_kv=20.)
b4 = pp.create_bus(net, vn_kv=10.)
tidx = pp.create_transformer3w(net,
b2,
b3,
b4,
std_type='63/25/38 MVA 110/20/10 kV')
pp.create_load(net, b3, p_mw=5)
pp.create_load(net, b4, p_mw=5)
pp.create_xward(net,
b4,
ps_mw=1,
qs_mvar=1,
pz_mw=1,
qz_mvar=1,
r_ohm=0.1,
x_ohm=0.1,
vm_pu=1.0)
net.trafo3w.shift_lv_degree.at[tidx] = 120
net.trafo3w.shift_mv_degree.at[tidx] = 80
pp.runpp(net)
va = net.res_bus.va_degree.at[b2]
pp.runpp(net, calculate_voltage_angles=True, init_va_degree="dc")
assert np.allclose(va - net.trafo3w.shift_mv_degree.at[tidx],
net.res_bus.va_degree.at[b3],
atol=2)
assert np.allclose(va - net.trafo3w.shift_lv_degree.at[tidx],
net.res_bus.va_degree.at[b4],
atol=2)
pp.runpp(net, calculate_voltage_angles=True, init_va_degree="results")
assert np.allclose(va - net.trafo3w.shift_mv_degree.at[tidx],
net.res_bus.va_degree.at[b3],
atol=2)
assert np.allclose(va - net.trafo3w.shift_lv_degree.at[tidx],
net.res_bus.va_degree.at[b4],
atol=2)
def test_mixed_p_q_pol():
vm_max = 1.05
vm_min = 0.95
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_gen(net, 1, p_mw=0.1, controllable=True, min_p_mw=0.005, max_p_mw=0.15, max_q_mvar=.05,
min_q_mvar=-.05)
pp.create_ext_grid(net, 0)
pp.create_load(net, 1, p_mw=0.02, controllable=False, max_q_mvar=.05, max_p_mw=0.1, min_p_mw=0.0050,
min_q_mvar=-.05)
pp.create_line_from_parameters(net, 0, 1, 50, name="line2", r_ohm_per_km=0.876,
c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
# testing some combinations
pp.create_poly_cost(net, 0, "gen", cp1_eur_per_mw=1, cq1_eur_per_mvar=1)
pp.runopp(net)
assert net["OPF_converged"]
assert np.isclose(net.res_cost, (net.res_gen.p_mw.values + net.res_gen.q_mvar.values))
def recycle_net():
net = pp.create_empty_network()
b1, b2, ln = add_grid_connection(net)
pl = 1.2
ql = 1.1
ps = 0.5
u_set = 1.0
b3 = pp.create_bus(net, vn_kv=.4)
pp.create_bus(net, vn_kv=.4, in_service=False)
pp.create_line_from_parameters(net,
b2,
b3,
12.2,
r_ohm_per_km=0.08,
x_ohm_per_km=0.12,
c_nf_per_km=300,
max_i_ka=.2,
df=.8)
pp.create_load(net, b3, p_mw=pl, q_mvar=ql)
pp.create_gen(net, b2, p_mw=ps, vm_pu=u_set)
return net
def test_create_sgens_raise_except():
net = pp.create_empty_network()
# standard
b1 = pp.create_bus(net, 110)
b2 = pp.create_bus(net, 110)
b3 = pp.create_bus(net, 110)
with pytest.raises(UserWarning, match=r"Cannot attach to buses \{3, 4, 5\}, they do not exist"):
pp.create_sgens(
net, buses=[3, 4, 5], p_mw=[0, 0, 1], q_mwar=0., controllable=[True, False, False],
max_p_mw=0.2, min_p_mw=[0, 0.1, 0], max_q_mvar=0.2, min_q_mvar=[0, 0.1, 0], k=1.3,
rx=0.4, current_source=True)
sg = pp.create_sgens(
net, buses=[b1, b2, b3], p_mw=[0, 0, 1], q_mwar=0., controllable=[True, False, False],
max_p_mw=0.2, min_p_mw=[0, 0.1, 0], max_q_mvar=0.2, min_q_mvar=[0, 0.1, 0], k=1.3, rx=0.4,
current_source=True)
with pytest.raises(UserWarning, match=r"Sgens with indexes \[0 1 2\] already exist"):
pp.create_sgens(
net, buses=[b1, b2, b3], p_mw=[0, 0, 1], q_mwar=0., controllable=[True, False, False],
max_p_mw=0.2, min_p_mw=[0, 0.1, 0], max_q_mvar=0.2, min_q_mvar=[0, 0.1, 0], k=1.3,
rx=0.4, current_source=True, index=sg)
def test_cost_piecewise_linear_eg():
""" Testing a very simple network for the resulting cost value
constraints with OPF """
# boundaries:
vm_max = 1.05
vm_min = 0.95
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10)
pp.create_ext_grid(net, 0, max_p_kw=0, min_p_kw=-50)
pp.create_gen(net,
1,
p_kw=-10,
max_p_kw=0,
min_p_kw=-50,
controllable=True)
# pp.create_ext_grid(net, 0)
pp.create_load(net, 1, p_kw=20, controllable=False)
pp.create_line_from_parameters(net,
0,
1,
50,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
pp.create_piecewise_linear_cost(net, 0, "ext_grid",
np.array([[-50, -500], [0, 0]]))
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost - -net.res_ext_grid.p_kw.values * 10 < 1e-3
def test_net_no_load():
# Reference power in the s generator
psg1 = 163
psg2 = 85
net = pp.create_empty_network()
pp.set_user_pf_options(net,
init_vm_pu="flat",
init_va_degree="dc",
calculate_voltage_angles=True)
b0 = pp.create_bus(net, p_mw=0, q_mw=0, vn_kv=110, name="bus0")
b1 = pp.create_bus(net, p_mw=163, q_mw=0, vn_kv=110, name="bus1")
b2 = pp.create_bus(net, p_mw=85, q_mw=0, vn_kv=110, name="bus2")
b3 = pp.create_bus(net, vn_kv=110, name="bus3")
b4 = pp.create_bus(net, p_mw=90, q_mw=30, vn_kv=110, name="bus4")
b5 = pp.create_bus(net, vn_kv=110, name="bus5")
b6 = pp.create_bus(net, p_mw=100, q_mw=35, vn_kv=110, name="bus6")
b7 = pp.create_bus(net, vn_kv=110, name="bus7")
b8 = pp.create_bus(net, p_mw=125, q_mw=50, vn_kv=110, name="bus8")
pp.create_line(net, b0, b3, 10, "149-AL1/24-ST1A 110.0")
pp.create_line(net, b1, b7, 10, "149-AL1/24-ST1A 110.0")
pp.create_line(net, b3, b8, 10, "149-AL1/24-ST1A 110.0")
pp.create_line(net, b7, b8, 10, "149-AL1/24-ST1A 110.0")
pp.create_line(net, b3, b4, 10, "149-AL1/24-ST1A 110.0")
pp.create_line(net, b7, b8, 10, "149-AL1/24-ST1A 110.0")
pp.create_line(net, b5, b6, 10, "149-AL1/24-ST1A 110.0")
pp.create_line(net, b5, b4, 10, "149-AL1/24-ST1A 110.0")
pp.create_line(net, b2, b5, 10, "149-AL1/24-ST1A 110.0")
pp.create_load(net, b4, p_mw=90, q_mvar=30, name='load1')
#pp.create_load(net, b6, p_mw=125, q_mvar=50, name='load2')
pp.create_load(net, b8, p_mw=100, q_mvar=35, name='load3')
pp.create_gen(net, b0, p_mw=0, name='gen1', slack=True)
pp.create_sgen(net, b1, p_mw=psg1, q_mvar=0, name='sgen1')
pp.create_sgen(net, b2, p_mw=psg2, q_mvar=0, name='sgen2')
return net
def motor_net():
net = pp.create_empty_network(sn_mva=10)
b1 = pp.create_bus(net, vn_kv=0.4)
b2 = pp.create_bus(net, vn_kv=0.4)
b3 = pp.create_bus(net, vn_kv=0.4)
pp.create_ext_grid(net,
b1,
s_sc_max_mva=10.,
rx_max=0.1,
s_sc_min_mva=8.,
rx_min=0.1)
pp.create_line_from_parameters(net,
from_bus=b1,
to_bus=b2,
length_km=1.,
r_ohm_per_km=0.32,
c_nf_per_km=0,
x_ohm_per_km=0.07,
max_i_ka=1,
endtemp_degree=80)
pp.create_motor(net,
b2,
pn_mech_mw=0.5,
lrc_pu=7.,
vn_kv=0.45,
rx=0.4,
efficiency_n_percent=95,
cos_phi_n=0.9,
cos_phi=0.9)
pp.create_line_from_parameters(net,
from_bus=b2,
to_bus=b3,
length_km=2.,
r_ohm_per_km=0.32,
c_nf_per_km=0,
x_ohm_per_km=0.07,
max_i_ka=1,
endtemp_degree=80)
return net
def net():
v_base = 110 # 110kV Base Voltage
k_va_base = 100 # 100 MVA
# I_base = (kVA_base/V_base) * 1e-3 # in kA
net = pp.create_empty_network(sn_mva=k_va_base)
pp.create_bus(net, vn_kv=v_base, index=1)
pp.create_bus(net, vn_kv=v_base, index=5)
pp.create_ext_grid(net,
bus=1,
vm_pu=1.0,
s_sc_max_mva=5000,
rx_max=0.1,
r0x0_max=0.1,
x0x_max=1.0)
pp.create_std_type(
net, {
"r0_ohm_per_km": 0.0848,
"x0_ohm_per_km": 0.4649556,
"c0_nf_per_km": 230.6,
"max_i_ka": 0.963,
"r_ohm_per_km": 0.0212,
"x_ohm_per_km": 0.1162389,
"c_nf_per_km": 230
}, "example_type")
pp.create_line(net,
from_bus=1,
to_bus=5,
length_km=50.0,
std_type="example_type")
pp.create_asymmetric_load(net,
5,
p_a_mw=50,
q_a_mvar=50,
p_b_mw=10,
q_b_mvar=15,
p_c_mw=10,
q_c_mvar=5)
return net
def _create_empty_network_with_transformer(trafotype, V_OS=10., V_US=0.4):
"""
Creates a Network with transformer and infeeder. The reference bus on the \
high-voltage side is called "Trafostation_OS". The bus on the low-voltage \
side is called "main_busbar".
The voltage levels can be set manually and the transformer parameter can \
be set with "ti"
"""
pd_net = pp.create_empty_network()
NFA2X4x70 = {"c_nf_per_km": 0, "r_ohm_per_km": 0.443, "x_ohm_per_km": 0.069, "max_i_ka": 0.270,
"type": "ol", "q_mm2": 70}
NAYY4x50 = {"c_nf_per_km": 670, "r_ohm_per_km": 0.6417, "x_ohm_per_km": 0.084823,
"max_i_ka": 0.141, "type": "cs", "q_mm2": 50}
NAYY4x150 = {"c_nf_per_km": 830, "r_ohm_per_km": 0.2067, "x_ohm_per_km": 0.08042478,
"max_i_ka": 0.275, "type": "cs", "q_mm2": 150}
NAYY4x185 = {"c_nf_per_km": 830, "r_ohm_per_km": 0.165, "x_ohm_per_km": 0.08042478,
"max_i_ka": 0.313, "type": "cs", "q_mm2": 185}
NYY4x35 = {"c_nf_per_km": 0, "r_ohm_per_km": 0.5240284, "x_ohm_per_km": 0.08513716,
"max_i_ka": 0.156, "type": "cs", "q_mm2": 35}
pp.create_std_type(net=pd_net, data=NFA2X4x70, name="NFA2X 4x70", element="line")
pp.create_std_type(net=pd_net, data=NAYY4x50, name="NAYY 4x50", element="line")
pp.create_std_type(net=pd_net, data=NAYY4x150, name="NAYY 4x150", element="line")
pp.create_std_type(net=pd_net, data=NAYY4x185, name="NAYY 4x185", element="line")
pp.create_std_type(net=pd_net, data=NYY4x35, name="NYY 4x35", element="line")
T100kVA = {"sn_mva": 0.100, "vn_hv_kv": 10, "vn_lv_kv": 0.4, "vk_percent": 4,
"vkr_percent": 1.2, "pfe_kw": 0.45, "i0_percent": 0.25, "shift_degree": 150,
"vector_group": "Dyn5"}
T160kVA = {"sn_mva": 0.160, "vn_hv_kv": 10, "vn_lv_kv": 0.4, "vk_percent": 4,
"vkr_percent": 1.2, "pfe_kw": 0.38, "i0_percent": 0.26, "shift_degree": 150,
"vector_group": "Dyn5"}
pp.create_std_type(net=pd_net, data=T100kVA, name="0.1 MVA 10/0.4 kV", element="trafo")
pp.create_std_type(net=pd_net, data=T160kVA, name="0.16 MVA 10/0.4 kV", element="trafo")
busnr1 = pp.create_bus(pd_net, name="Trafostation_OS", vn_kv=V_OS)
pp.create_ext_grid(pd_net, bus=busnr1)
main_busbar_nr = pp.create_bus(pd_net, name="main_busbar", vn_kv=V_US, type="b")
pp.create_transformer(pd_net, hv_bus=busnr1, lv_bus=main_busbar_nr, std_type=trafotype,
name="trafo 1")
return pd_net, main_busbar_nr
def test_cost_piecewise_linear_load_uneven_slopes():
""" Testing a very simple network for the resulting cost value
constraints with OPF """
# boundaries:
vm_max = 1.05
vm_min = 0.95
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_load(net,
1,
p_kw=100,
controllable=True,
max_p_kw=150,
min_p_kw=50,
max_q_kvar=0,
min_q_kvar=0)
pp.create_ext_grid(net, 0)
pp.create_line_from_parameters(net,
0,
1,
50,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
pp.create_piecewise_linear_cost(net, 0, "load",
np.array([[0, 0], [75, 51], [150, 101]]))
# run OPF
with pytest.raises(OPFNotConverged):
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert abs(net.res_cost - net.res_load.p_kw.values / 1.5) < 1e-3
def test_cost_piecewise_linear_sgen_very_unsteady_slopes():
""" Testing a very simple network for the resulting cost value
constraints with OPF """
# boundaries:
vm_max = 1.5
vm_min = 0.5
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_sgen(net,
1,
p_kw=-1000,
controllable=True,
max_p_kw=0,
min_p_kw=-1500,
max_q_kvar=50,
min_q_kvar=-50)
pp.create_ext_grid(net, 0)
pp.create_load(net, 1, p_kw=20, controllable=False)
pp.create_line_from_parameters(net,
0,
1,
50,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
pp.create_piecewise_linear_cost(net, 0, "sgen",
np.array([[-1500, 2], [-750, 1], [0, 2]]))
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
def test_network_with_trafo3w_pq():
net = pp.create_empty_network()
bus_slack = pp.create_bus(net, vn_kv=110)
pp.create_ext_grid(net, bus=bus_slack)
bus_20_1 = pp.create_bus(net, vn_kv=20,name="b")
pp.create_sgen(net, bus=bus_20_1, p_mw=0.03, q_mvar=0.02)
bus_10_1 = pp.create_bus(net, vn_kv=10)
pp.create_sgen(net, bus=bus_10_1, p_mw=0.02, q_mvar=0.02)
bus_10_2 = pp.create_bus(net, vn_kv=10)
pp.create_load(net, bus=bus_10_2, p_mw=0.06, q_mvar=0.01)
pp.create_line(net, from_bus=bus_10_1, to_bus=bus_10_2, std_type="149-AL1/24-ST1A 10.0", length_km=2)
pp.create_transformer3w(net, bus_slack, bus_20_1, bus_10_1, std_type="63/25/38 MVA 110/20/10 kV")
pp.runpp(net)
pp.create_measurement(net, "p", "line", net.res_line.p_from_mw[0], 0.001, 0, 'from')
pp.create_measurement(net, "q", "line", net.res_line.q_from_mvar[0], 0.001, 0, 'from')
pp.create_measurement(net, "p", "line", net.res_line.p_to_mw[0], 0.001, 0, 'to')
pp.create_measurement(net, "q", "line", net.res_line.q_to_mvar[0], 0.001, 0, 'to')
pp.create_measurement(net, "p", "trafo3w", net.res_trafo3w.p_hv_mw[0], 0.001, 0, 'hv')
pp.create_measurement(net, "q", "trafo3w", net.res_trafo3w.q_hv_mvar[0], 0.001, 0, 'hv')
pp.create_measurement(net, "p", "trafo3w", net.res_trafo3w.p_mv_mw[0], 0.002, 0, 'mv')
pp.create_measurement(net, "q", "trafo3w", net.res_trafo3w.q_mv_mvar[0], 0.002, 0, 'mv')
pp.create_measurement(net, "p", "trafo3w", net.res_trafo3w.p_lv_mw[0], 0.001, 0, 'lv')
pp.create_measurement(net, "q", "trafo3w", net.res_trafo3w.q_lv_mvar[0], 0.001, 0, 'lv')
pp.create_measurement(net, "v", "bus", net.res_bus.vm_pu[0], 0.01, 0)
pp.create_measurement(net, "v", "bus", net.res_bus.vm_pu[1], 0.01, 1)
success = estimate(net)
assert success
assert (np.nanmax(np.abs(net.res_bus.vm_pu.values - net.res_bus_est.vm_pu.values)) < 0.006)
assert (np.nanmax(np.abs(net.res_bus.va_degree.values- net.res_bus_est.va_degree.values)) < 0.006)
def test_two_oos_buses():
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=0.4)
b2 = pp.create_bus(net, vn_kv=0.4)
b3 = pp.create_bus(net, vn_kv=0.4, in_service=False)
b4 = pp.create_bus(net, vn_kv=0.4, in_service=False)
pp.create_ext_grid(net, b1)
l1 = pp.create_line(net, b1, b2, 0.5, std_type="NAYY 4x50 SE", index=4)
l2 = pp.create_line(net, b2, b3, 0.5, std_type="NAYY 4x50 SE", index=2)
l3 = pp.create_line(net, b3, b4, 0.5, std_type="NAYY 4x50 SE", index=7)
pp.runpp(net)
assert net.res_line.loading_percent.at[l1] > 0
assert net.res_line.loading_percent.at[l2] > 0
assert np.isnan(net.res_line.loading_percent.at[l3])
net.line.drop(l2, inplace=True)
pp.runpp(net)
assert net.res_line.loading_percent.at[l1] > 0
assert np.isnan(net.res_line.loading_percent.at[l3])
def gen_three_bus_example():
net = pp.create_empty_network(sn_mva=2)
b1 = pp.create_bus(net, vn_kv=10.)
b2 = pp.create_bus(net, vn_kv=10.)
b3 = pp.create_bus(net, vn_kv=10.)
#pp.create_bus(net, vn_kv=0.4, in_service=False)
pp.create_gen(net,
b2,
vn_kv=10.5,
xdss_pu=0.2,
rdss_pu=0.001,
cos_phi=0.8,
p_mw=0.1,
sn_mva=2.5)
pp.create_line_from_parameters(net,
b1,
b2,
length_km=1.0,
max_i_ka=0.29,
r_ohm_per_km=0.1548,
x_ohm_per_km=0.0816814,
c_nf_per_km=165)
pp.create_line_from_parameters(net,
b2,
b3,
length_km=1.0,
max_i_ka=0.29,
r_ohm_per_km=0.1548,
x_ohm_per_km=0.0816814,
c_nf_per_km=165)
net.line["endtemp_degree"] = 165
pp.create_ext_grid(net,
b1,
s_sc_max_mva=10.,
s_sc_min_mva=8.,
rx_min=0.4,
rx_max=0.4)
#pp.create_switch(net, b3, b1, et="b")
return net
def test_fuse_buses():
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=1, name="b1")
b2 = pp.create_bus(net, vn_kv=1.5, name="b2")
line1 = pp.create_line(net, b2, b1, length_km=1, std_type="NAYY 4x50 SE")
sw1 = pp.create_switch(net, b2, line1, et="l")
sw2 = pp.create_switch(net, b1, b2, et="b")
load1 = pp.create_load(net, b1, p_kw=6)
load2 = pp.create_load(net, b2, p_kw=5)
tb.fuse_buses(net, b1, b2, drop=True)
# assertion: elements connected to b2 are given to b1 instead
assert net["line"]["from_bus"].loc[0] == b1
assert net["switch"]["bus"].loc[0] == b1
assert net["load"]["bus"].loc[1] == b1
# assertion: b2 not in net.bus table if drop=True
assert b2 not in net.bus.index
def motor_net():
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, s_sc_max_mva=10., rx_max=0.1)
pp.create_line_from_parameters(net,
from_bus=b1,
to_bus=b2,
length_km=1.,
r_ohm_per_km=0.3211,
x_ohm_per_km=0.06911504,
c_nf_per_km=0,
max_i_ka=1)
pp.create_sgen(net,
b2,
p_mw=0.11,
sn_mva=0.5,
type="motor",
k=7,
rx=0.6,
current_source=False)
return net
def feeder_network():
net = pp.create_empty_network()
b1 = pp.create_bus(net, 110)
b2 = pp.create_bus(net, 110)
b3 = pp.create_bus(net, 110)
b4 = pp.create_bus(net, 110)
b5 = 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.)
pp.create_line(net,
b1,
b4,
std_type="305-AL1/39-ST1A 110.0",
length_km=12.)
pp.create_line(net,
b4,
b5,
std_type="N2XS(FL)2Y 1x185 RM/35 64/110 kV",
length_km=8.)
net.line["endtemp_degree"] = 80
for b in [b2, b3, b4, b5]:
pp.create_sgen(net, b, sn_kva=2000, p_kw=0)
net.sgen["k"] = 1.2
return net
def net():
v_base = 20 # 20kV Base Voltage
mva_base = 100 # 100 MVA
Net = pp.create_empty_network(sn_mva=mva_base)
bus0 = pp.create_bus(Net, vn_kv=v_base, name="Bus 0")
pp.create_ext_grid(Net, bus=bus0, vm_pu=1.0, name="Grid Connection", s_sc_max_mva=5000,
rx_max=0.1, r0x0_max=0.1, x0x_max=1.0)
bus1 = pp.create_bus(Net, name="Bus1", vn_kv=20, type="b")
#pp.add_zero_impedance_parameters(Net)
pp.create_asymmetric_load(Net, bus1, p_a_mw=0.3, q_a_mvar=0.003, p_b_mw=0.2, q_b_mvar=0.002,
p_c_mw=0.1, q_c_mvar=0.001, scaling=1.0, in_service=True, type='wye')
pp.create_line_from_parameters(Net, from_bus=bus0, to_bus=bus1, length_km=2.0, r0_ohm_per_km=.789,
x0_ohm_per_km=0.306, c0_nf_per_km=272.9, max_i_ka=0.496,
r_ohm_per_km=0.184, x_ohm_per_km=0.1900664, c_nf_per_km=273)
return Net
def test_power_station_unit():
net = pp.create_empty_network()
b1, b2, b3, b4 = pp.create_buses(net, 4, 20)
b5 = pp.create_bus(net, 10)
pp.create_ext_grid(net, b1, s_sc_max_mva=250, rx_max=0.1)
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_transformer_from_parameters(net, b4, b5, 25, 20, 10, 0.41104,
10.3, 0.1, 0.1)
pp.create_gen(net,
b5,
vn_kv=10,
xdss_pu=0.12,
cos_phi=0.8,
p_mw=0,
sn_mva=10)
sc.calc_sc(net)
def test_generator_as_slack():
net = pp.create_empty_network()
b1 = pp.create_bus(net, 110.)
pp.create_ext_grid(net, b1, vm_pu=1.02)
b2 = pp.create_bus(net, 110.)
pp.create_line(net,
b1,
b2,
length_km=70.,
std_type='149-AL1/24-ST1A 110.0')
pp.create_load(net, b2, p_mw=2)
pp.runpp(net)
res_bus = net.res_bus.vm_pu.values
pp.create_gen(net, b1, p_mw=0.1, vm_pu=1.02, slack=True)
net.ext_grid.in_service.iloc[0] = False
pp.runpp(net)
assert np.allclose(res_bus, net.res_bus.vm_pu.values)
net.gen.slack.iloc[0] = False
with pytest.raises(UserWarning):
pp.runpp(net)
def test_create_buses():
net = pp.create_empty_network()
# standard
b1 = pp.create_buses(net, 3, 110)
# with geodata
b2 = pp.create_buses(net, 3, 110, geodata=(10, 20))
# with geodata as array
geodata = np.array([[10, 20], [20, 30], [30, 40]])
b3 = pp.create_buses(net, 3, 110, geodata=geodata)
assert len(net.bus) == 9
assert len(net.bus_geodata) == 6
for i in b2:
assert net.bus_geodata.at[i, 'x'] == 10
assert net.bus_geodata.at[i, 'y'] == 20
assert (net.bus_geodata.loc[b3, ['x', 'y']].values == geodata).all()
# no way of creating buses with not matching shape
with pytest.raises(ValueError):
pp.create_buses(net, 2, 110, geodata=geodata)
def test_recycle():
# Note: Only calls recycle functions and tests if load and gen are updated.
# Todo: To fully test the functionality, it must be checked if the recycle methods are being called
# or alternatively if the "non-recycle" functions are not being called.
net = pp.create_empty_network()
b1, b2, ln = add_grid_connection(net)
pl = 1200
ql = 1100
ps = -500
u_set = 1.0
b3 = pp.create_bus(net, vn_kv=.4)
pp.create_line_from_parameters(net, b2, b3, 12.2, r_ohm_per_km=0.08, x_ohm_per_km=0.12,
c_nf_per_km=300, max_i_ka=.2, df=.8)
pp.create_load(net, b3, p_kw=pl, q_kvar=ql)
pp.create_gen(net, b2, p_kw=ps, vm_pu=u_set)
runpp_with_consistency_checks(net, recycle=dict(_is_elements=True, ppc=True, Ybus=True))
# copy.deepcopy(net)
# update values
pl = 600
ql = 550
ps = -250
u_set = 0.98
net["load"].p_kw.iloc[0] = pl
net["load"].q_kvar.iloc[0] = ql
net["gen"].p_kw.iloc[0] = ps
net["gen"].vm_pu.iloc[0] = u_set
runpp_with_consistency_checks(net, recycle=dict(_is_elements=True, ppc=True, Ybus=True))
assert np.allclose(net.res_load.p_kw.iloc[0], pl)
assert np.allclose(net.res_load.q_kvar.iloc[0], ql)
assert np.allclose(net.res_gen.p_kw.iloc[0], ps)
assert np.allclose(net.res_gen.vm_pu.iloc[0], u_set)
def test_cost_piecewise_linear_load():
""" Testing a very simple network for the resulting cost value
constraints with OPF """
# boundaries:
vm_max = 1.05
vm_min = 0.95
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_load(net,
1,
p_mw=0.1,
controllable=True,
max_p_mw=0.15,
min_p_mw=0.050,
max_q_mvar=0,
min_q_mvar=0)
pp.create_ext_grid(net, 0)
pp.create_line_from_parameters(net,
0,
1,
50,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
pp.create_pwl_cost(net, 0, "load", [[0, 75, 1.5], [75, 150, 1.5]])
pp.runopp(net)
assert net["OPF_converged"]
assert abs(net.res_cost - net.res_load.p_mw.values * 1.5) < 1e-3
def test_close_switch_at_line_with_two_open_switches():
net = pp.create_empty_network()
bus1 = pp.create_bus(net, vn_kv=.4)
bus2 = pp.create_bus(net, vn_kv=.4)
bus3 = pp.create_bus(net, vn_kv=.4)
line1 = pp.create_line(net,
bus2,
bus3,
length_km=1.,
std_type="NAYY 4x50 SE")
line2 = pp.create_line(net,
bus2,
bus3,
length_km=1.,
std_type="NAYY 4x50 SE")
line3 = pp.create_line(net,
bus2,
bus3,
length_km=1.,
std_type="NAYY 4x50 SE")
sw1 = pp.create_switch(net, bus1, bus2, et="b", closed=True)
sw2 = pp.create_switch(net, bus2, line1, et="l", closed=False)
sw3 = pp.create_switch(net, bus3, line1, et="l", closed=False)
sw4 = pp.create_switch(net, bus2, line2, et="l", closed=True)
sw5 = pp.create_switch(net, bus3, line2, et="l", closed=False)
sw6 = pp.create_switch(net, bus3, line2, et="l", closed=True)
sw7 = pp.create_switch(net, bus3, line2, et="l", closed=True)
tb.close_switch_at_line_with_two_open_switches(net)
# assertion: sw2 closed
assert net.switch.closed.loc[1]
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)
