def test_3ph_isolated_nodes():
v_base = 110 # 110kV Base Voltage
mva_base = 100 # 100 MVA
net = pp.create_empty_network(sn_mva=mva_base)
busn = pp.create_bus(net, vn_kv=v_base, name="busn", index=1)
pp.create_bus(net, vn_kv=20., in_service=True, index=2, name="busx")
busk = pp.create_bus(net, vn_kv=v_base, name="busk", index=5)
busl = pp.create_bus(net, vn_kv=v_base, name="busl", index=6)
pp.create_bus(net, vn_kv=20., in_service=False, index=3)
busy = pp.create_bus(net, vn_kv=20., in_service=True, index=0, name="busy")
pp.create_ext_grid(net, bus=busn, vm_pu=1.0, name="Grid Connection",
s_sc_max_mva=5000, rx_max=0.1)
net.ext_grid["r0x0_max"] = 0.1
net.ext_grid["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")
# Loads on supplied buses
pp.create_asymmetric_load(net, busk, 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.create_load(net, bus=busl, p_mw=7, q_mvar=0.070, name="Load 1")
# Loads on unsupplied buses
pp.create_load(net, bus=busy, p_mw=70, q_mvar=70, name="Load Y")
pp.create_line(net, from_bus=busn, to_bus=busk, length_km=50.0, std_type="example_type")
pp.create_line(net, from_bus=busl, to_bus=busk, length_km=50.0, std_type="example_type")
pp.add_zero_impedance_parameters(net)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
assert np.allclose(net.res_bus_3ph.T[[0, 2, 3]].T[["vm_a_pu", "va_a_degree", "vm_b_pu",
"va_b_degree", "vm_c_pu", "va_c_degree"]], np.nan, equal_nan=True)
assert np.allclose(net.res_bus_3ph.T[[0, 2, 3]].T[["p_a_mw", "q_a_mvar", "p_b_mw", "q_b_mvar",
"p_c_mw", "q_c_mvar"]], 0.0)
def test_2trafos():
net = pp.create_empty_network()
make_nw(net, 10., 0., "wye", "YNyn")
make_nw(net, 10., 0., "wye", "YNyn")
runpp_3ph_with_consistency_checks(net)
assert net['converged']
assert np.allclose(net.res_ext_grid_3ph.iloc[0].values, net.res_ext_grid_3ph.iloc[1].values)
def test_3ph_bus_mapping_order():
net = pp.create_empty_network()
b2 = pp.create_bus(net, vn_kv=0.4, index=4)
pp.create_bus(net, vn_kv=0.4, in_service=False, index=3)
b1 = pp.create_bus(net, vn_kv=0.4, index=7)
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, 1.0, std_type="N2XRY 3x185sm 0.6/1kV", index=4)
pp.create_line(net, b1, b2, 1.0, std_type="N2XRY 3x185sm 0.6/1kV", index=3, in_service=False)
pp.create_line(net, b1, b2, 1.0, std_type="N2XRY 3x185sm 0.6/1kV", index=7)
pp.add_zero_impedance_parameters(net)
pp.create_load(net, b2, p_mw=0.030, q_mvar=0.030)
pp.runpp(net)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
assert np.allclose(net.res_bus_3ph.vm_a_pu.values, net.res_bus.vm_pu.values, equal_nan=True)
assert net.res_bus_3ph.index.tolist() == net.res_bus.index.tolist()
assert net.res_line_3ph.index.tolist() == net.res_line.index.tolist()
assert np.allclose(net.res_line.p_from_mw, net.res_line_3ph.p_a_from_mw +
net.res_line_3ph.p_b_from_mw +
net.res_line_3ph.p_c_from_mw)
assert np.allclose(net.res_line.loading_percent, net.res_line_3ph.loading_a_percent)
def test_2bus_network_single_isolated_busses(net):
# -o---o o x
pp.create_bus(net, vn_kv=110)
pp.create_bus(net, vn_kv=110, in_service=False)
pp.add_zero_impedance_parameters(net)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
check_it(net)
def test_trafo_asym():
nw_dir = os.path.abspath(os.path.join(pp.pp_dir, "test/loadflow"))
for trafo_vector_group in ["YNyn", "Dyn", "Yzn"]:
net = pp.from_json(nw_dir + '/runpp_3ph Validation.json')
net['trafo'].vector_group = trafo_vector_group
runpp_3ph_with_consistency_checks(net)
assert net['converged']
check_results(net, trafo_vector_group, get_PF_Results(trafo_vector_group))
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_trafo_asym():
results = get_PF_Results() # Results taken out from PF
for bushv in [10]:
for tap_ps in [0]:
for loadtyp in ["delta", "wye", "delta_wye", "bal_wye"]:
for vc in ["YNyn", "Dyn", "Yzn"]: # ,"Yyn"]:
net = pp.create_empty_network(sn_mva=100)
make_nw(net, bushv, tap_ps, loadtyp, vc)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
check_results(net, vc, results[bushv][tap_ps][loadtyp][vc])
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_out_serv_load(net):
# <-x--o------o
pp.add_zero_impedance_parameters(net)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
check_it(net)
pp.create_asymmetric_load(net, 5, p_a_mw=50, q_a_mvar=100, p_b_mw=29, q_b_mvar=38,
p_c_mw=10, q_c_mvar=5, in_service=False)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
check_it(net)
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_2bus_network(net):
# -o---o
pp.add_zero_impedance_parameters(net)
runpp_3ph_with_consistency_checks(net)
assert net['converged']
check_it(net)
def test_4bus_network():
v_base = 110 # 110kV Base Voltage
mva_base = 100 # 100 MVA
net = pp.create_empty_network(sn_mva=mva_base)
# =============================================================================
# Main Program
# =============================================================================
busn = pp.create_bus(net, vn_kv=v_base, name="busn")
busk = pp.create_bus(net, vn_kv=v_base, name="busk")
busm = pp.create_bus(net, vn_kv=v_base, name="busm")
busp = pp.create_bus(net, vn_kv=v_base, name="busp")
pp.create_ext_grid(net,
bus=busn,
vm_pu=1.0,
name="Grid Connection",
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": .154,
"x0_ohm_per_km": 0.5277876,
"c0_nf_per_km": 170.4,
"max_i_ka": 0.741,
"r_ohm_per_km": .0385,
"x_ohm_per_km": 0.1319469,
"c_nf_per_km": 170
}, "example_type3")
pp.create_line(net,
from_bus=busn,
to_bus=busm,
length_km=1.0,
std_type="example_type3")
pp.create_line(net,
from_bus=busn,
to_bus=busp,
length_km=1.0,
std_type="example_type3")
pp.create_line_from_parameters(net,
from_bus=busn,
to_bus=busk,
length_km=1.0,
r0_ohm_per_km=.1005,
x0_ohm_per_km=0.4900884,
c0_nf_per_km=200.5,
max_i_ka=0.89,
r_ohm_per_km=.0251,
x_ohm_per_km=0.1225221,
c_nf_per_km=210)
pp.create_line_from_parameters(net,
from_bus=busk,
to_bus=busm,
length_km=1.0,
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)
pp.create_line_from_parameters(net,
from_bus=busk,
to_bus=busp,
length_km=1.0,
r0_ohm_per_km=.3048,
x0_ohm_per_km=0.6031856,
c0_nf_per_km=140.3,
max_i_ka=0.531,
r_ohm_per_km=.0762,
x_ohm_per_km=0.1507964,
c_nf_per_km=140)
pp.add_zero_impedance_parameters(net)
pp.create_asymmetric_load(net,
busk,
p_a_mw=50,
q_a_mvar=20,
p_b_mw=80,
q_b_mvar=60,
p_c_mw=20,
q_c_mvar=5)
pp.create_asymmetric_load(net,
busm,
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.create_asymmetric_load(net,
busp,
p_a_mw=50,
q_a_mvar=20,
p_b_mw=60,
q_b_mvar=20,
p_c_mw=10,
q_c_mvar=5)
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'
]][~np.isnan(net.res_bus_3ph.vm_a_pu)].values)
bus_pf = np.abs(
np.array([[0.98085729, 0.97711997, 1.04353786],
[0.97828577, 0.97534651, 1.04470864],
[0.97774307, 0.97648197, 1.04421233],
[0.9780892, 0.97586805, 1.04471106]]))
assert np.max(np.abs(bus_pp - bus_pf)) < 1e-8
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',
'loading_a_percent', 'loading_b_percent', 'loading_c_percent',
'loading_percent'
]].values)
line_pf = np.abs(
np.array([[
0.98898804851, 0.68943734, 0.19848961, 0.99093993, 0.69146384,
0.19966503, 49.87434308, 33.86579548, 12.44659879, 36.16562613,
26.14426519, 4.25746428, -49.75842138, -33.90236497, -12.45155362,
-36.19862688, -26.25675246, -4.50384238, 133.730100000000,
93.314960000000, 26.945350000000, 133.730100000000
],
[
0.87075816277, 1.03463205, 0.19072622, 0.87210779,
1.03599167, 0.19188991, 49.59359423, 58.53676842,
11.97553941, 21.96967200, 26.37559958, 4.04458873,
-49.47110289, -58.55284705, -11.98669516, -22.07474008,
-26.34476811, -4.29078447, 117.693400000000,
139.809900000000, 25.896070000000, 139.809900000000
],
[
0.95760407055, 1.14786582, 0.24829126, 0.95975383,
1.15028040, 0.24975553, 50.87938854, 57.53628873,
15.54470531, 31.13888557, 41.99378843, 5.39758513,
-50.76249094, -57.56374777, -15.56099267, -31.28560646,
-41.99056453, -5.69609575, 107.837500000000,
129.245000000000, 28.062420000000, 129.245000000000
],
[
0.21780921494, 0.42795803, 0.03706412, 0.22229619,
0.42603286, 0.03771703, 0.23292404, -23.88471674,
-2.45255095, 13.53037092, -11.49972060, 0.17971665,
-0.24157862, 23.90236497, 2.45155361, -13.80137312,
11.25675247, -0.49615762, 23.083720000000,
44.440090000000, 3.916618000000, 44.440090000000
],
[
0.03712221482, 0.10766244, 0.03093505, 0.03446871,
0.10500386, 0.03179428, 0.52956690, 1.44846452,
-1.98645639, -2.24476446, -6.50971485, 0.51637910,
-0.52889712, -1.44715295, 1.98669515, 2.07474008,
6.34476812, -0.70921554, 6.991001000000, 20.275410000000,
5.987624000000, 20.275410000000
]]))
assert np.max(np.abs(line_pp - line_pf)) < 1e-4
