def test_drop_inactive_elements():
net = pp.create_empty_network()
service = 0
bus0 = pp.create_bus(net, vn_kv=.4, in_service=service)
pp.create_ext_grid(net, bus0, in_service=service)
bus1 = pp.create_bus(net, vn_kv=.4, in_service=service)
pp.create_transformer(net, bus0, bus1, in_service=service,
std_type= '63 MVA 110/20 kV')
bus2 = pp.create_bus(net, vn_kv=.4, in_service=service)
pp.create_line(net, bus1, bus2, length_km=1, in_service=service,
std_type='149-AL1/24-ST1A 10.0')
pp.create_load(net, bus2, p_kw=0., in_service=service)
pp.create_sgen(net, bus2, p_kw=0., in_service=service)
# drop them
tb.drop_inactive_elements(net)
sum_of_elements = 0
for element in net.keys():
# skip this one since we expect items here
if element == "std_types":
continue
try:
sum_of_elements += len(net[element])
except TypeError:
# _ppc is initialized with None and clashes when checking
continue
assert sum_of_elements == 0
def 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,
x0x_max=0.2,
x0x_min=0.1,
r0x0_max=0.3,
r0x0_min=0.2)
net.ext_grid['x0x_min'] = 0.1
net.ext_grid['r0x0_min'] = 0.1
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['r0_ohm_per_km'] = 0.1
net.line['x0_ohm_per_km'] = 0.1
net.line['c0_nf_per_km'] = 0.1
net.line["endtemp_degree"] = 80
pp.create_sgen(net, b2, sn_mva=2, p_mw=0, k=1.2)
return net
def test_contingency_sgen(base_net):
net = base_net
pp.create_sgen(net,
1,
p_kw=-100,
q_kvar=0,
controllable=True,
max_p_kw=-5,
min_p_kw=-150,
max_q_kvar=50,
min_q_kvar=-50)
# pwl costs
# maximize the sgen feed in by using a positive cost slope
# using a slope of 1
# | /
# | /
# | /
# |/
#-------------------------------------------
# p_min_kw /|
# / |
# / |
pp.create_piecewise_linear_cost(
net, 0, "sgen",
array([[net.sgen.min_p_kw.at[0], net.sgen.min_p_kw.at[0]], [0, 0]]))
pp.runopp(net)
assert abs(net.res_cost - net.res_sgen.p_kw.at[0]) < 1e-5
# minimize the sgen feed in by using a positive cost slope
# using a slope of 1
# \ |
# \ |
# \ |
# \|
#-------------------------------------------
# p_min_kw |\
# | \
# | \
net.piecewise_linear_cost.f.at[0] *= -1
pp.runopp(net)
assert abs(net.res_cost - net.res_sgen.p_kw.at[0] * -1) < 1e-5
try:
net.piecewise_linear_cost = net.piecewise_linear_cost.drop(index=0)
except:
net.piecewise_linear_cost = net.piecewise_linear_cost.drop(0)
# first using a positive slope as in the case above
pp.create_polynomial_cost(net, 0, "sgen", array([1, 0]))
pp.runopp(net)
assert abs(net.res_cost - net.res_sgen.p_kw.at[0]) < 1e-5
# negative slope as in the case above
net.polynomial_cost.c.at[0] *= -1
pp.runopp(net)
assert abs(net.res_cost - net.res_sgen.p_kw.at[0] * -1) < 1e-5
def test_wye_delta():
from pandapower.pypower.idx_brch import BR_R, BR_X, BR_B
net = pp.create_empty_network()
pp.create_bus(net, vn_kv=110)
pp.create_buses(net, nr_buses=4, vn_kv=20)
trafo = pp.create_transformer(net, hv_bus=0, lv_bus=1, std_type='25 MVA 110/20 kV')
pp.create_line(net, 1, 2, length_km=2.0, std_type="NAYY 4x50 SE")
pp.create_line(net, 2, 3, length_km=6.0, std_type="NAYY 4x50 SE")
pp.create_line(net, 3, 4, length_km=10.0, std_type="NAYY 4x50 SE")
pp.create_ext_grid(net, 0)
pp.create_load(net, 4, p_mw=0.1)
pp.create_sgen(net, 2, p_mw=4.)
pp.create_sgen(net, 3, p_mw=4.)
pp.runpp(net, trafo_model="pi")
f, t = net._pd2ppc_lookups["branch"]["trafo"]
assert np.isclose(net.res_trafo.p_hv_mw.at[trafo], -7.560996, rtol=1e-7)
assert np.allclose(net._ppc["branch"][f:t, [BR_R, BR_X, BR_B]].flatten(),
np.array([0.0001640 + 0.j, 0.0047972 + 0.j, -0.0105000 - 0.014j]),
rtol=1e-7)
pp.runpp(net, trafo_model="t")
assert np.allclose(net._ppc["branch"][f:t, [BR_R, BR_X, BR_B]].flatten(),
np.array([0.00016392 + 0.j, 0.00479726 + 0.j, -0.01050009 - 0.01399964j]))
assert np.isclose(net.res_trafo.p_hv_mw.at[trafo], -7.561001, rtol=1e-7)
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 test_cost_pol_q():
""" 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_sgen(net, 1, p_mw=0.1, controllable=True, min_p_mw=0.005, 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_poly_cost(net, 0, "sgen", cp1_eur_per_mw=0, cq1_eur_per_mvar=-1)
# run OPF
pp.runopp(net)
assert net["OPF_converged"]
assert abs(net.res_cost + (net.res_sgen.q_mvar.values)) < 1e-2
net.poly_cost.cq1_eur_per_mvar.at[0] = 0
net.poly_cost.cq2_eur_per_mvar2.at[0] = 1
# net.poly_cost.c.at[0] = np.array([[1, 0, 0]])
# run OPF
pp.runopp(net)
assert net["OPF_converged"]
assert np.isclose(net.res_cost, net.res_sgen.q_mvar.values**2)
def test_cost_piecewise_linear_sgen_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_sgen(net, 1, p_kw=-100, controllable=True, max_p_kw=-5, min_p_kw=-150, 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([[-150, 200], [-75, 50], [0, 0]]))
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost - net.res_sgen.p_kw.values / 1.5 < 1e-3
def three_bus_big_sgen_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 add_test_bus_bus_switch(net):
b1, b2, ln = add_grid_connection(net, zone="test_bus_bus_switch")
b3 = pp.create_bus(net, vn_kv=20., zone="test_bus_bus_switch")
pp.create_switch(net, b2, b3, et="b")
pl = 1000
ql = 500
psg = -500
qsg = 100
pz = 1200
qz = 1100
ps = 500
qs = 200
vm_pu = 1.06
r_ohm = 50
x_ohm = 70
pp.create_load(net, b2, p_kw=pl, q_kvar=ql)
pp.create_load(net, b3, p_kw=pl, q_kvar=ql, scaling=0.5)
pp.create_sgen(net, b2, p_kw=psg, q_kvar=qsg)
pp.create_sgen(net, b3, p_kw=psg, q_kvar=qsg, scaling=0.5)
pp.create_ward(net, b2, pz_kw=pz, qz_kvar=qz, ps_kw=ps, qs_kvar=qs)
pp.create_ward(net, b3, pz_kw=0.5 * pz, qz_kvar=0.5 * qz, ps_kw=0.5 * ps, qs_kvar=0.5 * qs)
pp.create_xward(net, b3, pz_kw=0.5 * pz, qz_kvar=0.5 * qz, ps_kw=0.5 * ps, qs_kvar=0.5 * qs,
vm_pu=vm_pu, x_ohm=x_ohm, r_ohm=r_ohm)
pp.create_xward(net, b2, pz_kw=pz, qz_kvar=qz, ps_kw=ps, qs_kvar=qs,
vm_pu=vm_pu, x_ohm=x_ohm, r_ohm=r_ohm)
net.last_added_case = "test_bus_bus_switch"
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_balanced_power_flow_with_unbalanced_loads_and_sgens():
net = pp.create_empty_network(sn_mva=100)
make_nw(net, 10, 0, "wye", "Dyn")
pp.create_asymmetric_sgen(net, 1, p_a_mw=0.01, p_b_mw=0.02, scaling=0.8)
runpp_with_consistency_checks(net)
vm_pu = net.res_bus.vm_pu
net.asymmetric_load.in_service = False
pp.create_load(
net,
bus=net.asymmetric_load.bus.iloc[0],
scaling=net.asymmetric_load.scaling.iloc[0],
p_mw=net.asymmetric_load.loc[0, ["p_a_mw", "p_b_mw", "p_c_mw"]].sum(),
q_mvar=net.asymmetric_load.loc[
0, ["q_a_mvar", "q_b_mvar", "q_c_mvar"]].sum())
runpp_with_consistency_checks(net)
assert net.res_bus.vm_pu.equals(vm_pu)
net.asymmetric_sgen.in_service = False
pp.create_sgen(
net,
bus=net.asymmetric_sgen.bus.iloc[0],
scaling=net.asymmetric_sgen.scaling.iloc[0],
p_mw=net.asymmetric_sgen.loc[0, ["p_a_mw", "p_b_mw", "p_c_mw"]].sum(),
q_mvar=net.asymmetric_sgen.loc[
0, ["q_a_mvar", "q_b_mvar", "q_c_mvar"]].sum())
runpp_with_consistency_checks(net)
assert net.res_bus.vm_pu.equals(vm_pu)
def test_cost_pol_q():
""" 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_sgen(net, 1, p_kw=-100, controllable=True, max_p_kw=-5, min_p_kw=-150, 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_polynomial_cost(net, 0, "sgen", np.array([0, -1, 0]), type="q")
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert abs(net.res_cost + (net.res_sgen.q_kvar.values)) < 1e-2
net.polynomial_cost.c.at[0] = np.array([[1, 0, 0]])
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert abs(net.res_cost - net.res_sgen.q_kvar.values**2) < 1e-5
def net():
net = networks.create_kerber_vorstadtnetz_kabel_1()
for i, load in net.load.iterrows():
pp.create_sgen(net, load.bus, p_mw=1 * 1e-3, sn_mva=2 * 1e-3)
return net
def simple_network():
net = pp.create_empty_network()
b1 = pp.create_bus(net, name="bus1", vn_kv=10.)
pp.create_ext_grid(net, b1)
b2 = pp.create_bus(net, name="bus2", geodata=(1, 2))
b3 = pp.create_bus(net, name="bus3", geodata=(1, 3))
b4 = pp.create_bus(net, name="bus4", vn_kv=10.)
pp.create_transformer(net,
b4,
b2,
std_type="0.25 MVA 10/0.4 kV",
name=None,
in_service=True,
index=None)
pp.create_line(net,
b2,
b3,
1,
name="line1",
std_type="NAYY 4x150 SE",
geodata=np.array([[1, 2], [3, 4]]))
pp.create_line(net, b1, b4, 1, name="line2", std_type="NAYY 4x150 SE")
pp.create_load(net, b2, p_mw=0.01, q_mvar=0, name="load1")
pp.create_load(net, b3, p_mw=0.04, q_mvar=0.002, name="load2")
pp.create_gen(net, 3, q_mvar=0.020, vm_pu=1.0)
pp.create_sgen(net, 2, p_mw=0.050, sn_mva=0.1)
return net
def test_cost_piecewise_linear_sgen():
""" 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_sgen(net, 1, p_mw=-0.1, controllable=True, max_p_mw=-0.005, min_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, "sgen", [[-150, -75, 1.5], [-75, 0, -1.5]])
# run OPF
pp.runopp(net, )
assert net["OPF_converged"]
assert net.res_cost - net.res_sgen.p_mw.values / 1.5 < 1e-3
def test_connectivity_check_island_without_pv_bus():
# Network with islands without pv bus -> all buses in island should be set out of service
net = create_cigre_network_mv(with_der=False)
iso_buses, iso_p, iso_q = get_isolated(net)
assert len(iso_buses) == 0
assert np.isclose(iso_p, 0)
assert np.isclose(iso_q, 0)
isolated_bus1 = pp.create_bus(net, vn_kv=20., name="isolated Bus1")
isolated_bus2 = pp.create_bus(net, vn_kv=20., name="isolated Bus2")
pp.create_line(net,
isolated_bus2,
isolated_bus1,
length_km=1,
std_type="N2XS(FL)2Y 1x300 RM/35 64/110 kV",
name="IsolatedLine")
iso_buses, iso_p, iso_q = get_isolated(net)
assert len(iso_buses) == 2
assert np.isclose(iso_p, 0)
assert np.isclose(iso_q, 0)
pp.create_load(net, isolated_bus1, p_kw=200., q_kvar=20)
pp.create_sgen(net, isolated_bus2, p_kw=-150., q_kvar=-10)
# with pytest.warns(UserWarning):
iso_buses, iso_p, iso_q = get_isolated(net)
assert len(iso_buses) == 2
assert np.isclose(iso_p, 350)
assert np.isclose(iso_q, 30)
# with pytest.warns(UserWarning):
runpp_with_consistency_checks(net, check_connectivity=True)
def create_test_network():
"""Creates a simple pandapower test network
"""
net = pp.create_empty_network()
b1 = pp.create_bus(net, name="bus1", vn_kv=10.)
pp.create_ext_grid(net, b1)
b2 = pp.create_bus(net, name="bus2", geodata=(1, 2), vn_kv=.4)
b3 = pp.create_bus(net, name="bus3", geodata=(1, 3), vn_kv=.4, index=7)
b4 = pp.create_bus(net, name="bus4", vn_kv=10.)
pp.create_transformer_from_parameters(net, b4, b2, vk_percent=3.75,
tap_max=2, vn_lv_kv=0.4,
shift_degree=150, tap_neutral=0,
vn_hv_kv=10.0, vkr_percent=2.8125,
tap_pos=0, tap_side="hv", tap_min=-2,
tap_step_percent=2.5, i0_percent=0.68751,
sn_mva=0.016, pfe_kw=0.11, name=None,
in_service=True, index=None)
# 0.016 MVA 10/0.4 kV ET 16/23 SGB
pp.create_line_from_parameters(net, b2, b3, 1, name="line1", r_ohm_per_km=0.2067,
ices=0.389985, c_nf_per_km=720.0, max_i_ka=0.328,
x_ohm_per_km=0.1897522, geodata=np.array([[1, 2], [3, 4]]))
# NAYY 1x150RM 0.6/1kV ir
pp.create_line_from_parameters(net, b1, b4, 1, 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)
# NAYSEY 3x35rm/16 6/10kV
pp.create_load(net, b2, p_mw=0.010, q_mvar=0, name="load1")
pp.create_load(net, b3, p_mw=0.040, q_mvar=0.002, name="load2")
pp.create_gen(net, b4, p_mw=0.200, vm_pu=1.0)
pp.create_sgen(net, b3, p_mw=0.050, sn_mva=0.1)
return net
def test_pmu_with_trafo3w():
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)
add_virtual_pmu_meas_from_loadflow(net, with_random_error=False)
run_se_lp_verify(net)
def simple_four_bus_system():
"""
This function creates a simple four bus system with two radial low voltage nodes connected to \
a medium valtage slack bus. At both low voltage nodes the a load and a static generator is \
connected.
RETURN:
**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)
pp.create_ext_grid(net, busnr1)
busnr2 = pp.create_bus(net, name="bus2", vn_kv=.4)
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)
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)
pp.create_line(net, busnr3, busnr4, name="line2", length_km=0.50000, std_type="NAYY 4x50 SE")
pp.create_load(net, busnr3, 30, 10, name="load1")
pp.create_load(net, busnr4, 30, 10, name="load2")
pp.create_sgen(net, busnr3, p_kw=-20., q_kvar=-5., name="pv1", sn_kva=30)
pp.create_sgen(net, busnr4, p_kw=-15., q_kvar=-2., name="pv2", sn_kva=20)
return net
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_kw=110, sn_kva=500, type="motor", k=7, rx=0.6)
return net
def _change_ref_bus(net, ref_bus_idx, ext_grid_p=0):
"""
This function changes the current reference bus / buses, declared by net.ext_grid.bus towards \
the given 'ref_bus_idx'
If ext_grid_p is a list, it must be in the same order as net.ext_grid.index.
"""
# cast ref_bus_idx and ext_grid_p as list
if not isinstance(ref_bus_idx, list):
ref_bus_idx = [ref_bus_idx]
if not isinstance(ext_grid_p, list):
ext_grid_p = [ext_grid_p]
for i in ref_bus_idx:
if i not in net.gen.bus.values and i not in net.ext_grid.bus.values:
raise ValueError(
"Index %i is not in net.gen.bus or net.ext_grid.bus." % i)
# determine indeces of ext_grid and gen connected to ref_bus_idx
gen_idx = net.gen.loc[net.gen.bus.isin(ref_bus_idx)].index
ext_grid_idx = net.ext_grid.loc[~net.ext_grid.bus.isin(ref_bus_idx)].index
# old ext_grid -> gen
j = 0
for i in ext_grid_idx:
ext_grid_data = net.ext_grid.loc[i]
net.ext_grid.drop(i, inplace=True)
pp.create_gen(net,
ext_grid_data.bus,
ext_grid_p[j],
vm_pu=ext_grid_data.vm_pu,
controllable=True,
min_q_kvar=ext_grid_data.min_q_kvar,
max_q_kvar=ext_grid_data.max_q_kvar,
min_p_kw=ext_grid_data.min_p_kw,
max_p_kw=ext_grid_data.max_p_kw)
j += 1
# store gen data
gen_data = net.gen.loc[gen_idx]
net.gen.drop(net.gen.index[gen_idx], inplace=True)
# old gen at ref_bus -> ext_grid (and sgen)
for i in gen_idx:
gen_i_data = gen_data.loc[i]
if gen_i_data.bus not in net.ext_grid.bus.values:
pp.create_ext_grid(net,
gen_i_data.bus,
vm_pu=gen_i_data.vm_pu,
va_degree=0.,
min_q_kvar=gen_i_data.min_q_kvar,
max_q_kvar=gen_i_data.max_q_kvar,
min_p_kw=gen_i_data.min_p_kw,
max_p_kw=gen_i_data.max_p_kw)
else:
pp.create_sgen(net,
gen_i_data.bus,
p_kw=gen_i_data.p_kw,
min_q_kvar=gen_i_data.min_q_kvar,
max_q_kvar=gen_i_data.max_q_kvar,
min_p_kw=gen_i_data.min_p_kw,
max_p_kw=gen_i_data.max_p_kw)
def test_drop_inactive_elements():
for service in (False, True):
net = pp.create_empty_network()
bus_sl = pp.create_bus(net, vn_kv=.4, in_service=service)
pp.create_ext_grid(net, bus_sl, in_service=service)
bus0 = pp.create_bus(net, vn_kv=.4, in_service=service)
pp.create_switch(net, bus_sl, bus0, 'b', not service)
bus1 = pp.create_bus(net, vn_kv=.4, in_service=service)
pp.create_transformer(net, bus0, bus1, in_service=service,
std_type='63 MVA 110/20 kV')
bus2 = pp.create_bus(net, vn_kv=.4, in_service=service)
pp.create_line(net, bus1, bus2, length_km=1, in_service=service,
std_type='149-AL1/24-ST1A 10.0')
pp.create_load(net, bus2, p_mw=0., in_service=service)
pp.create_sgen(net, bus2, p_mw=0., in_service=service)
bus3 = pp.create_bus(net, vn_kv=.4, in_service=service)
bus4 = pp.create_bus(net, vn_kv=.4, in_service=service)
pp.create_transformer3w_from_parameters(net, bus2, bus3, bus4, 0.4, 0.4, 0.4, 100, 50, 50,
3, 3, 3, 1, 1, 1, 5, 1)
# drop them
tb.drop_inactive_elements(net)
sum_of_elements = 0
for element, table in net.items():
# skip this one since we expect items here
if element.startswith("_") or not isinstance(table, pd.DataFrame):
continue
try:
if service and (element == 'ext_grid' or (element == 'bus' and len(net.bus) == 1)):
# if service==True, the 1 ext_grid and its bus are not dropped
continue
if len(table) > 0:
sum_of_elements += len(table)
print(element)
except TypeError:
# _ppc is initialized with None and clashes when checking
continue
assert sum_of_elements == 0
if service:
assert len(net.ext_grid) == 1
assert len(net.bus) == 1
assert bus_sl in net.bus.index.values
net = pp.create_empty_network()
bus0 = pp.create_bus(net, vn_kv=.4, in_service=True)
pp.create_ext_grid(net, bus0, in_service=True)
bus1 = pp.create_bus(net, vn_kv=.4, in_service=False)
pp.create_line(net, bus0, bus1, length_km=1, in_service=False,
std_type='149-AL1/24-ST1A 10.0')
gen0 = pp.create_gen(net, bus=bus1, p_mw=0.001)
tb.drop_inactive_elements(net)
assert gen0 not in net.gen.index
def check_energy(self, user_send, load_indices):
print(user_send)
for id1, send in user_send.items():
violated, violation_type = self.violations(self._net)
if violated:
break
else:
bus_number = load_indices[id1]
pp.create_sgen(self._net, bus_number, send / 1000, q_mvar=1)
return (violated, violation_type)
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_scaling_by_type():
net = pp.create_empty_network()
bus0 = pp.create_bus(net, 0.4)
pp.create_load(net, bus0, p_kw=0., type="Household")
pp.create_sgen(net, bus0, p_kw=0., type="PV")
tb.set_scaling_by_type(net, {"Household": 42., "PV": 12})
assert net.load.at[0, "scaling"] == 42
assert net.sgen.at[0, "scaling"] == 12
def test_opf_varying_max_line_loading():
""" Testing a simple network with transformer for loading
constraints with OPF using a generator """
# boundaries
vm_max = 1.5
vm_min = 0.5
max_trafo_loading = 800
max_line_loading = 13
# 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_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_transformer_from_parameters(net, 0, 1, vk_percent=3.75, tap_max=2, vn_lv_kv=0.4,
shift_degree=150, tap_neutral=0, vn_hv_kv=10.0,
vkr_percent=2.8125, tap_pos=0, tap_side="hv", tap_min=-2,
tap_step_percent=2.5, i0_percent=0.68751, sn_mva=0.016,
pfe_kw=0.11, name=None, in_service=True, index=None,
max_loading_percent=max_trafo_loading)
pp.create_sgen(net, 3, p_mw=0.1, controllable=True, min_p_mw=0.005, max_p_mw=0.15, max_q_mvar=0.025,
min_q_mvar=-0.025)
pp.create_sgen(net, 2, p_mw=0.1, controllable=True, min_p_mw=0.005, max_p_mw=0.15, max_q_mvar=0.025,
min_q_mvar=-0.025)
pp.create_poly_cost(net, 0, "sgen", cp1_eur_per_mw=10)
pp.create_poly_cost(net, 1, "sgen", cp1_eur_per_mw=10)
pp.create_ext_grid(net, 0)
pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=.1)
pp.create_line_from_parameters(net, 1, 2, 1, name="line1", r_ohm_per_km=0.876,
c_nf_per_km=260.0, max_i_ka=0.200, x_ohm_per_km=0.1159876,
max_loading_percent=20)
pp.create_line_from_parameters(net, 1, 3, 1, name="line2", r_ohm_per_km=0.876,
c_nf_per_km=260.0, max_i_ka=0.100, x_ohm_per_km=0.1159876,
max_loading_percent=10)
# run OPF
pp.runopp(net, init="flat")
assert net["OPF_converged"]
assert np.allclose(net["_ppc"]["branch"][:, 5], np.array([0.02771281+0.j, 0.00692820+0.j, 0.12800000+0.j]))
# assert and check result
logger.debug("test_opf_sgen_loading")
logger.debug("res_sgen:\n%s" % net.res_sgen)
logger.debug("res_line.loading_percent:\n%s" % net.res_line.loading_percent)
assert net.res_line.loading_percent.at[0] - 20 < 1e-2
logger.debug("res_line.loading_percent:\n%s" % net.res_line.loading_percent)
assert net.res_line.loading_percent.at[1] - 10 < 1e-2
def test_contingency_sgen(base_net):
net = base_net
pp.create_sgen(net,
1,
p_mw=0.1,
q_mvar=0,
controllable=True,
min_p_mw=0.005,
max_p_mw=0.150,
max_q_mvar=0.05,
min_q_mvar=-0.05)
# pwl costs
# maximize the sgen feed in by using a positive cost slope
# using a slope of 1
# | /
# | /
# | /
# |/
#-------------------------------------------
# p_min_mw /|
# / |
# / |
pwl = pp.create_pwl_cost(net, 0, "sgen", [[0, net.sgen.max_p_mw.at[0], 1]])
pp.runopp(net)
assert isclose(net.res_cost, net.res_sgen.p_mw.at[0], atol=1e-3)
# minimize the sgen feed in by using a positive cost slope
# using a slope of 1
# \ |
# \ |
# \ |
# \|
#-------------------------------------------
# p_min_mw |\
# | \
# | \
net.pwl_cost.points.loc[pwl] = [(0, net.sgen.max_p_mw.at[0], -1)]
pp.runopp(net)
assert isclose(net.res_cost, -net.res_sgen.p_mw.at[0], atol=1e-4)
net.pwl_cost.drop(0, inplace=True)
# first using a positive slope as in the case above
pp.create_poly_cost(net, 0, "sgen", cp1_eur_per_mw=1.)
pp.runopp(net)
assert isclose(net.res_cost, net.res_sgen.p_mw.at[0], atol=1e-3)
# negative slope as in the case above
net.poly_cost.cp1_eur_per_mw.at[0] *= -1
pp.runopp(net)
assert isclose(net.res_cost, -net.res_sgen.p_mw.at[0], atol=1e-4)
def add_test_load_sgen_split(net):
b1, b2, ln = add_grid_connection(net, zone="test_load_sgen_split")
nr = 2
pl = 1.2
ql = 1.1
ps = 0.5
qs = -0.1
for _ in list(range(nr)):
pp.create_load(net, b2, p_mw=pl, q_mvar=ql, scaling=1. / nr)
pp.create_sgen(net, b2, p_mw=ps, q_mvar=qs, scaling=1. / nr)
net.last_added_case = "test_load_sgen_split"
return net
def test_3point_pwl():
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_sgen(net,
1,
p_mw=0.1,
q_mvar=0,
controllable=True,
min_p_mw=0.1,
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)
# creating a pwl cost function that actually is realistic: The absolute value of the reactive power has costs.
pp.create_pwl_cost(net,
0,
"sgen", [[-50, 0, -1.5], [0, 50, 1.5]],
power_type="q")
pp.runopp(net)
# The reactive power should be at zero to minimze the costs.
assert np.isclose(net.res_sgen.q_mvar.values, 0, atol=1e-4)
assert np.isclose(net.res_cost,
abs(net.res_sgen.q_mvar.values) * 1.5,
atol=1e-4)
#TODO costs seem to be assigned to ext_grid, not to sgen (net.res_ext_grid.q_mvar*1.5=net.res_cost)
# They are however correctly assigned in the gencost array, this seems to be a bug in PYPOWER
net.sgen.min_q_mvar = 0.05
net.sgen.max_q_mvar = 0.1
pp.runopp(net)
assert np.isclose(net.res_sgen.q_mvar.values, 0.05, atol=1e-4)
assert np.isclose(net.res_cost,
abs(net.res_sgen.q_mvar.values) * 1.5,
atol=1e-4)
def add_test_load_sgen_split(net):
b1, b2, ln = add_grid_connection(net, zone="test_load_sgen_split")
nr = 2
pl = 1200
ql = 1100
ps = -500
qs = 100
for _ in list(range(nr)):
pp.create_load(net, b2, p_kw=pl, q_kvar=ql, scaling=1. / nr)
pp.create_sgen(net, b2, p_kw=ps, q_kvar=qs, scaling=1. / nr)
net.last_added_case = "test_load_sgen_split"
return net
