def add_test_ward(net):
b1, b2, ln = add_grid_connection(net, zone="test_ward")
pz = 1.2
qz = 1.1
ps = 0.5
qs = 0.2
# one shunt at a bus
pp.create_ward(net, b2, pz_mw=pz, qz_mvar=qz, ps_mw=ps, qs_mvar=qs)
# add out of service ward shuold not change the result
pp.create_ward(net,
b2,
pz_mw=pz,
qz_mvar=qz,
ps_mw=ps,
qs_mvar=qs,
in_service=False,
index=pp.get_free_id(net.ward) + 1)
net.last_added_case = "test_ward"
return net
def test_voltage_angles():
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.)
b5 = pp.create_bus(net, vn_kv=10., in_service=False)
tidx = pp.create_transformer3w(net,
b2,
b3,
b4,
std_type='63/25/38 MVA 110/20/10 kV',
max_loading_percent=120)
pp.create_load(net, b3, p_mw=5, controllable=False)
load_id = pp.create_load(net,
b4,
p_mw=5,
controllable=True,
max_p_mw=50,
min_p_mw=0,
min_q_mvar=-1e6,
max_q_mvar=1e6)
pp.create_poly_cost(net, load_id, "load", cp1_eur_per_mw=-1000)
net.trafo3w.shift_lv_degree.at[tidx] = 120
net.trafo3w.shift_mv_degree.at[tidx] = 80
custom_file = os.path.join(
os.path.abspath(os.path.dirname(pp.test.__file__)), "test_files",
"run_powermodels_custom.jl")
# TODO: pp.runpm_dc gives does not seem to consider the voltage angles. Is this intended behaviour?
for run in [pp.runpm_ac_opf, partial(pp.runpm, julia_file=custom_file)]:
run(net)
consistency_checks(net)
print(net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b3])
print(net.res_bus.va_degree.at[b1])
print(net.res_bus.va_degree.at[b3])
assert 119.9 < net.res_trafo3w.loading_percent.at[tidx] <= 120
assert 85 < (net.res_bus.va_degree.at[b1] -
net.res_bus.va_degree.at[b3]) % 360 < 86
assert 120 < (net.res_bus.va_degree.at[b1] -
net.res_bus.va_degree.at[b4]) % 360 < 130
assert np.isnan(net.res_bus.va_degree.at[b5])
def add_test_xward_combination(net):
b1, b2, ln = add_grid_connection(net, zone="test_xward_combination")
pz = 1200
qz = 1100
ps = 500
qs = 200
vm_pu = 1.06
r_ohm = 50
x_ohm = 70
# one xward at a bus
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)
# add out of service xward should not change the result
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, in_service=False)
# add second xward at the bus
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_xward_combination"
return net
def add_test_ward_split(net):
# splitting up the wards should not change results
pz = 1.2
qz = 1.1
ps = 0.5
qs = 0.2
b1, b2, ln = add_grid_connection(net, zone="test_ward_split")
pp.create_ward(net,
b2,
pz_mw=pz / 2,
qz_mvar=qz / 2,
ps_mw=ps / 2,
qs_mvar=qs / 2)
pp.create_ward(net,
b2,
pz_mw=pz / 2,
qz_mvar=qz / 2,
ps_mw=ps / 2,
qs_mvar=qs / 2)
net.last_added_case = "test_ward_split"
return net
def add_test_ward_split(net):
# splitting up the wards should not change results
pz = 1200
qz = 1100
ps = 500
qs = 200
b1, b2, ln = add_grid_connection(net, zone="test_ward_split")
pp.create_ward(net,
b2,
pz_kw=pz / 2,
qz_kvar=qz / 2,
ps_kw=ps / 2,
qs_kvar=qs / 2)
pp.create_ward(net,
b2,
pz_kw=pz / 2,
qz_kvar=qz / 2,
ps_kw=ps / 2,
qs_kvar=qs / 2)
net.last_added_case = "test_ward_split"
return net
def add_test_trafo(net):
b1, b2, ln = add_grid_connection(net, zone="test_trafo")
b3 = pp.create_bus(net, vn_kv=0.4, zone="test_trafo")
pp.create_transformer_from_parameters(net,
b2,
b3,
vsc_percent=5.,
vscr_percent=2.,
i0_percent=1.,
pfe_kw=20,
sn_kva=400,
vn_hv_kv=20,
vn_lv_kv=0.4)
t2 = pp.create_transformer_from_parameters(
net,
b2,
b3,
vsc_percent=5.,
vscr_percent=2.,
i0_percent=1.,
pfe_kw=20,
sn_kva=400,
vn_hv_kv=20,
vn_lv_kv=0.4,
index=pp.get_free_id(net.trafo) + 1)
pp.create_switch(net, b3, t2, et="t", closed=False)
pp.create_transformer_from_parameters(net,
b2,
b3,
vsc_percent=5.,
vscr_percent=2.,
i0_percent=1.,
pfe_kw=20,
sn_kva=400,
vn_hv_kv=20,
vn_lv_kv=0.4,
in_service=False)
pp.create_load(net, b3, p_kw=200, q_kvar=50)
net.last_added_case = "test_trafo"
return net
def add_test_oos_bus_with_is_element(net):
b1, b2, ln = add_grid_connection(net, zone="test_oos_bus_with_is_element")
pl = 1200
ql = 1100
ps = -500
u_set = 1.0
pz = 1200
qz = 1100
qs = 200
vm_pu = 1.06
r_ohm = 50
x_ohm = 70
# OOS buses
b3 = pp.create_bus(net, zone="test_oos_bus_with_is_element", vn_kv=0.4, in_service=False)
b4 = pp.create_bus(net, zone="test_oos_bus_with_is_element", vn_kv=0.4, in_service=False)
b5 = pp.create_bus(net, zone="test_oos_bus_with_is_element", vn_kv=0.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_line_from_parameters(net, b2, b4, 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_line_from_parameters(net, b2, b5, 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)
# in service elements
pp.create_load(net, b3, p_kw=pl, q_kvar=ql)
pp.create_gen(net, b4, p_kw=ps, vm_pu=u_set)
pp.create_sgen(net, b5, p_kw=ps, q_kvar=ql)
pp.create_ward(net, b3, pz_kw=pz, qz_kvar=qz, ps_kw=ps, qs_kvar=qs)
pp.create_xward(net, b4, 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_shunt(net, b5, q_kvar=-800, p_kw=0)
net.last_added_case = "test_oos_bus_with_is_element"
return net
def add_test_trafo_tap(net):
b1, b2, ln = add_grid_connection(net, zone="test_trafo_tap")
b3 = pp.create_bus(net, vn_kv=0.4, zone="test_trafo_tap")
pp.create_transformer_from_parameters(net,
b2,
b3,
vsc_percent=5.,
vscr_percent=2.,
i0_percent=1.,
pfe_kw=20,
sn_kva=400,
vn_hv_kv=22,
vn_lv_kv=0.4,
tp_max=10,
tp_mid=5,
tp_min=0,
tp_st_percent=1.25,
tp_pos=3,
tp_side="hv")
pp.create_load(net, b3, p_kw=200, q_kvar=50)
net.last_added_case = "test_trafo_tap"
return net
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_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_voltage_angles():
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.)
b5 = pp.create_bus(net, vn_kv=10., in_service=False)
tidx = pp.create_transformer3w(
net, b2, b3, b4, std_type='63/25/38 MVA 110/20/10 kV', max_loading_percent=120)
pp.create_load(net, b3, p_mw=5, controllable=False)
load_id = pp.create_load(net, b4, p_mw=5, controllable=True, max_p_mw=25, min_p_mw=0, min_q_mvar=-1e-6,
max_q_mvar=1e-6)
pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=1)
pp.create_poly_cost(net, load_id, "load", cp1_eur_per_mw=1000)
net.trafo3w.shift_lv_degree.at[tidx] = 10
net.trafo3w.shift_mv_degree.at[tidx] = 30
net.bus.loc[:, "max_vm_pu"] = 1.1
net.bus.loc[:, "min_vm_pu"] = .9
custom_file = os.path.join(os.path.abspath(os.path.dirname(pp.test.__file__)),
"test_files", "run_powermodels_custom.jl")
# load is zero since costs are high. PF results should be the same as OPF
net.load.loc[1, "p_mw"] = 0.
pp.runpp(net, calculate_voltage_angles=True)
va_degree = net.res_bus.loc[:, "va_degree"].values
vm_pu = net.res_bus.loc[:, "vm_pu"].values
loading3w = net.res_trafo3w.loc[:, "loading_percent"].values
for run in [pp.runpm_ac_opf, partial(pp.runpm, julia_file=custom_file)]:
run(net, calculate_voltage_angles=True)
consistency_checks(net)
assert 30. < (net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b3]) % 360 < 32.
assert 10. < (net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b4]) % 360 < 11.
assert np.isnan(net.res_bus.va_degree.at[b5])
assert np.allclose(net.res_bus.va_degree.values, va_degree, atol=1e-6, rtol=1e-6, equal_nan=True)
assert np.allclose(net.res_bus.vm_pu.values, vm_pu, atol=1e-6, rtol=1e-6, equal_nan=True)
assert np.allclose(net.res_trafo3w.loading_percent, loading3w, atol=1e-2, rtol=1e-2, equal_nan=True)
def test_makeYbus():
# tests if makeYbus fails for nets where every bus is connected to each other
net = pp.create_empty_network()
b1, b2, l1 = add_grid_connection(net)
# number of buses to create
n_bus = 20
bus_list = []
# generate buses and connect them
for _ in range(n_bus):
bus_list.append(pp.create_bus(net, vn_kv=20.))
# connect the first bus to slack node
create_test_line(net, bus_list[0], b2)
# iterate over every bus and add connection to every other bus
for bus_1 in bus_list:
for bus_2 in bus_list:
# add no connection to itself
if bus_1 == bus_2:
continue
create_test_line(net, bus_1, bus_2)
assert runpp_with_consistency_checks(net)
def network_with_trafo3ws():
net = pp.create_empty_network()
add_test_trafo(net)
slack, hv, ln = add_grid_connection(net, zone="test_trafo3w")
for _ in range(2):
mv = pp.create_bus(net, vn_kv=0.6, zone="test_trafo3w")
pp.create_load(net, mv, p_mw=0.8, q_mvar=0)
lv = pp.create_bus(net, vn_kv=0.4, zone="test_trafo3w")
pp.create_load(net, lv, p_mw=0.5, q_mvar=0)
t3 = pp.create_transformer3w_from_parameters(
net,
hv_bus=hv,
mv_bus=mv,
lv_bus=lv,
vn_hv_kv=22,
vn_mv_kv=.64,
vn_lv_kv=.42,
sn_hv_mva=1,
sn_mv_mva=0.7,
sn_lv_mva=0.3,
vk_hv_percent=1.,
vkr_hv_percent=.03,
vk_mv_percent=.5,
vkr_mv_percent=.02,
vk_lv_percent=.25,
vkr_lv_percent=.01,
pfe_kw=.5,
i0_percent=0.1,
name="test",
index=pp.get_free_id(net.trafo3w) + 1,
tap_side="hv",
tap_pos=2,
tap_step_percent=1.25,
tap_min=-5,
tap_neutral=0,
tap_max=5)
return (net, t3, hv, mv, lv)
def add_test_enforce_qlims(net):
b1, b2, ln = add_grid_connection(net, zone="test_enforce_qlims")
pl = 1200
ql = 1100
ps = -500
qmax = 200.
u_set = 1.0
b3 = pp.create_bus(net, zone="test_enforce_qlims", 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, b3, p_kw=ps, vm_pu=u_set, max_q_kvar=qmax)
net.last_added_case = "test_enforce_qlims"
return net
def test_rundcpp_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, 1, 1, 1, 1, 0.1, 0.1, 1.0)
net.trafo3w.shift_lv_degree.at[tidx] = 120
net.trafo3w.shift_mv_degree.at[tidx] = 80
pp.rundcpp(net)
va = net.res_bus.va_degree.at[b2]
pp.rundcpp(net)
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_voltage_angles():
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.)
b5 = pp.create_bus(net, vn_kv=10., in_service=False)
tidx = pp.create_transformer3w(
net, b2, b3, b4, std_type='63/25/38 MVA 110/20/10 kV', max_loading_percent=120)
pp.create_load(net, b3, p_mw=5, controllable=False)
load_id = pp.create_load(net, b4, p_mw=5, controllable=True, max_p_mw=25, min_p_mw=0, min_q_mvar=-1e-6,
max_q_mvar=1e-6)
pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=1)
pp.create_poly_cost(net, load_id, "load", cp1_eur_per_mw=1000)
net.trafo3w.shift_lv_degree.at[tidx] = 10
net.trafo3w.shift_mv_degree.at[tidx] = 30
net.bus.loc[:, "max_vm_pu"] = 1.1
net.bus.loc[:, "min_vm_pu"] = .9
# load is zero since costs are high. PF results should be the same as OPF
net.load.loc[1, "p_mw"] = 0.
pp.runpp(net, calculate_voltage_angles=True)
va_degree = net.res_bus.loc[:, "va_degree"].values
vm_pu = net.res_bus.loc[:, "vm_pu"].values
loading3w = net.res_trafo3w.loc[:, "loading_percent"].values
net_opf = copy.deepcopy(net)
pp.runpm_ac_opf(net_opf)
assert 30. < (net_opf.res_bus.va_degree.at[b1] - net_opf.res_bus.va_degree.at[b3]) % 360 < 32.
assert 10. < (net_opf.res_bus.va_degree.at[b1] - net_opf.res_bus.va_degree.at[b4]) % 360 < 11.
assert np.isnan(net_opf.res_bus.va_degree.at[b5])
assert np.allclose(net_opf.res_bus.va_degree.values, va_degree, atol=1e-6, rtol=1e-6, equal_nan=True)
assert np.allclose(net_opf.res_bus.vm_pu.values, vm_pu, atol=1e-6, rtol=1e-6, equal_nan=True)
assert np.allclose(net_opf.res_trafo3w.loading_percent, loading3w, atol=1e-2, rtol=1e-2, equal_nan=True)
def add_test_impedance(net):
b1, b2, ln = add_grid_connection(net, zone="test_impedance")
b3 = pp.create_bus(net, vn_kv=220., zone="test_impedance")
rij = 0.02
xij = 0.01
rji = 0.03
xji = 0.005
s = 2000
pl = 1000
ql = 500
pp.create_impedance(net,
b2,
b3,
rft_pu=rij,
xft_pu=xij,
rtf_pu=rji,
xtf_pu=xji,
sn_kva=s,
index=pp.get_free_id(net.impedance) + 1)
pp.create_load(net, b3, p_kw=pl, q_kvar=ql)
net.last_added_case = "test_impedance"
return net
def add_test_enforce_qlims(net):
b1, b2, ln = add_grid_connection(net, zone="test_enforce_qlims")
pl = 1.200
ql = 1.100
ps = 0.500
qmin = -0.200
vm_set_pu = 1.0
b3 = pp.create_bus(net, zone="test_enforce_qlims", 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_mw=pl, q_mvar=ql)
pp.create_gen(net, b3, p_mw=ps, vm_pu=vm_set_pu, min_q_mvar=qmin)
net.last_added_case = "test_enforce_qlims"
return net
def add_test_load_sgen(net):
b1, b2, ln = add_grid_connection(net, zone="test_load_sgen")
pl = 1.2
ql = 1.1
ps = 0.50
qs = -0.1
# load and sgen at one bus
pp.create_load(net, b2, p_mw=pl, q_mvar=ql)
pp.create_sgen(net, b2, p_mw=ps, q_mvar=qs)
# adding out of serivce loads and sgens should not change the result
pp.create_load(net,
b2,
p_mw=pl,
q_mvar=ql,
in_service=False,
index=pp.get_free_id(net.load) + 1)
pp.create_sgen(net,
b2,
p_mw=ps,
q_mvar=qs,
in_service=False,
index=pp.get_free_id(net.sgen) + 1)
net.last_added_case = "test_load_sgen"
return net
def test_trafo3w_switches():
net = pp.create_empty_network()
add_test_trafo(net)
slack, hv, ln = add_grid_connection(net, zone="test_trafo3w")
for _ in range(2):
mv = pp.create_bus(net, vn_kv=0.6, zone="test_trafo3w")
pp.create_load(net, mv, p_kw=800, q_kvar=0)
lv = pp.create_bus(net, vn_kv=0.4, zone="test_trafo3w")
pp.create_load(net, lv, p_kw=500, q_kvar=0)
t3 = pp.create_transformer3w_from_parameters(
net,
hv_bus=hv,
mv_bus=mv,
lv_bus=lv,
vn_hv_kv=22,
vn_mv_kv=.64,
vn_lv_kv=.42,
sn_hv_kva=1000,
sn_mv_kva=700,
sn_lv_kva=300,
vsc_hv_percent=1.,
vscr_hv_percent=.03,
vsc_mv_percent=.5,
vscr_mv_percent=.02,
vsc_lv_percent=.25,
vscr_lv_percent=.01,
pfe_kw=.5,
i0_percent=0.1,
name="test",
index=pp.get_free_id(net.trafo3w) + 1,
tp_side="hv",
tp_pos=2,
tp_st_percent=1.25,
tp_min=-5,
tp_mid=0,
tp_max=5)
# open switch at hv side - t3 is disconnected
s1 = pp.create_switch(net, bus=hv, element=t3, et="t3", closed=False)
runpp_with_consistency_checks(net)
assert np.isnan(net.res_bus.vm_pu.at[mv])
assert np.isnan(net.res_bus.vm_pu.at[lv])
assert np.isnan(net.res_trafo3w.p_hv_kw.at[t3]) == 0
# open switch at mv side - mv is disconnected, lv is connected
net.switch.bus.at[s1] = mv
runpp_with_consistency_checks(net)
assert np.isnan(net.res_bus.vm_pu.at[mv])
assert not np.isnan(net.res_bus.vm_pu.at[lv])
assert net.res_trafo3w.i_lv_ka.at[t3] > 1e-5
assert net.res_trafo3w.i_mv_ka.at[t3] < 1e-5
assert 490 < net.res_trafo3w.p_hv_kw.at[t3] < 510
# open switch at lv side - lv is disconnected, mv is connected
net.switch.bus.at[s1] = lv
runpp_with_consistency_checks(net)
assert np.isnan(net.res_bus.vm_pu.at[lv])
assert not np.isnan(net.res_bus.vm_pu.at[mv])
assert net.res_trafo3w.i_lv_ka.at[t3] < 1e-5
assert net.res_trafo3w.i_mv_ka.at[t3] > 1e-5
assert 790 < net.res_trafo3w.p_hv_kw.at[t3] < 810
# open switch at lv and mv side - lv and mv is disconnected, t3 in open loop
pp.create_switch(net, bus=mv, element=t3, et="t3", closed=False)
runpp_with_consistency_checks(net)
assert np.isnan(net.res_bus.vm_pu.at[lv])
assert np.isnan(net.res_bus.vm_pu.at[mv])
assert net.res_trafo3w.i_lv_ka.at[t3] < 1e-5
assert net.res_trafo3w.i_mv_ka.at[t3] < 1e-5
assert 0 < net.res_trafo3w.p_hv_kw.at[t3] < 1
def test_rundcpp_init():
net = pp.create_empty_network()
b1, b2, l1 = add_grid_connection(net)
b3 = pp.create_bus(net, vn_kv=0.4)
tidx = pp.create_transformer(net, hv_bus=b2, lv_bus=b3, std_type="0.25 MVA 20/0.4 kV")
pp.rundcpp(net)
def add_test_ext_grid(net):
b1, b2, ln = add_grid_connection(net, zone="test_ext_grid")
pp.create_ext_grid(net, b2, vm_pu=1.02)
return net
def add_test_ext_grid(net):
b1, b2, ln = add_grid_connection(net, zone="test_ext_grid")
b3 = pp.create_bus(net, vn_kv=20., zone="test_ext_grid")
create_test_line(net, b2, b3)
pp.create_ext_grid(net, b3, vm_pu=1.02, va_degree=3.)
return net
pp.create_shunt(net, b2, p_kw=pz / 2, q_kvar=qz / 2)
return net
def add_test_two_open_switches_on_deactive_line(net):
b1, b2, l1 = add_grid_connection(net,
zone="two_open_switches_on_deactive_line")
b3 = pp.create_bus(net, vn_kv=20.)
l2 = create_test_line(net, b2, b3, in_service=False)
create_test_line(net, b3, b1)
pp.create_switch(net, b2, l2, et="l", closed=False)
pp.create_switch(net, b3, l2, et="l", closed=False)
return net
if __name__ == '__main__':
net = pp.create_empty_network()
b1, b2, ln = add_grid_connection(net, zone="test_shunt")
pz = 120
qz = -1200
# one shunt at a bus
pp.create_shunt_as_condensator(net,
b2,
q_kvar=1200,
loss_factor=0.1,
vn_kv=20.,
step=1)
# add out of service shunt shuold not change the result
pp.create_shunt(net, b2, p_kw=pz, q_kvar=qz, in_service=False)
# add out of service shunt shuold not change the result
pp.runpp(net)
