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_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 test_zero_injection_aux_bus():
net = pp.create_empty_network()
bus1 = pp.create_bus(net, name="bus1", vn_kv=10.)
bus2 = pp.create_bus(net, name="bus2", vn_kv=10.)
bus3 = pp.create_bus(net, name="bus3", vn_kv=10.)
bus4 = pp.create_bus(net, name="bus4", vn_kv=110.)
pp.create_line_from_parameters(net, bus1, bus2, 10, r_ohm_per_km=.59, x_ohm_per_km=.35, c_nf_per_km=10.1,
max_i_ka=1)
pp.create_line_from_parameters(net, bus2, bus3, 10, r_ohm_per_km=.59, x_ohm_per_km=.35, c_nf_per_km=10.1,
max_i_ka=1)
pp.create_transformer(net, bus4, bus1, std_type="40 MVA 110/10 kV")
pp.create_ext_grid(net, bus=bus4, vm_pu=1.0)
pp.create_load(net, bus1, p_mw=.350, q_mvar=.100)
pp.create_load(net, bus2, p_mw=.450, q_mvar=.100)
pp.create_load(net, bus3, p_mw=.250, q_mvar=.100)
net.bus.at[bus3, 'in_service'] = False
# Created bb switch
pp.runpp(net, calculate_voltage_angles=True)
pp.create_measurement(net, "v", "bus", r2(net.res_bus.vm_pu.iloc[bus1], .002), .002, element=bus1)
pp.create_measurement(net, "v", "bus", r2(net.res_bus.vm_pu.iloc[bus4], .002), .002, element=bus4)
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[bus4], .002), .002, element=bus4)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[bus4], .002), .002, element=bus4)
# If measurement on the bus with bb-switch activated, it will incluence the results of the merged bus
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[bus2], .001), .001, element=bus2)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[bus2], .001), .001, element=bus2)
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[bus1], .001), .001, element=bus1)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[bus1], .001), .001, element=bus1)
pp.create_measurement(net, "p", "line", r2(net.res_line.p_from_mw.iloc[0], .002), .002, 0, side='from')
pp.create_measurement(net, "q", "line", r2(net.res_line.q_from_mvar.iloc[0], .002), .002, 0, side='from')
pp.create_measurement(net, "p", "trafo", r2(net.res_trafo.p_hv_mw.iloc[0], .001), .01,
side="hv", element=0)
pp.create_measurement(net, "q", "trafo", r2(net.res_trafo.q_hv_mvar.iloc[0], .001), .01,
side="hv", element=0)
net_auto = deepcopy(net)
net_aux = deepcopy(net)
success_none = estimate(net, tolerance=1e-5, zero_injection=None)
# In this case zero_injection in mode "aux_bus" and "auto" should be exact the same
success_aux = estimate(net_aux, tolerance=1e-5, zero_injection='aux_bus')
success_auto = estimate(net_auto, tolerance=1e-5, zero_injection='auto')
assert success_none and success_aux and success_auto
assert np.allclose(net_auto.res_bus_est.va_degree.values,net_aux.res_bus_est.va_degree.values, 1e-4, equal_nan=True)
assert np.allclose(net_auto.res_bus_est.vm_pu.values,net_aux.res_bus_est.vm_pu.values, 1e-4, equal_nan=True)
# in case zero injection was set to none, the results should be different
assert ~np.allclose(net.res_bus_est.vm_pu.values,net_aux.res_bus_est.vm_pu.values, 1e-2, equal_nan=True)
def test_convert_parallel_branches():
# create test grid
net = pp.create_empty_network()
pp.create_bus(net, 110)
pp.create_buses(net, 4, 20)
pp.create_ext_grid(net, 0)
pp.create_load(net, 4, 1e3, 4e2)
pp.create_transformer(net, 0, 1, "40 MVA 110/20 kV", name="sd", parallel=3)
pp.create_switch(net, 1, 0, "t", name="dfjk")
pp.create_line(net,
1,
2,
1.11,
"94-AL1/15-ST1A 20.0",
name="sdh",
parallel=2)
pp.create_switch(net, 2, 0, "l", name="dfsdf")
pp.create_line(net,
2,
3,
1.11,
"94-AL1/15-ST1A 20.0",
name="swed",
parallel=1)
pp.create_line(net,
3,
4,
1.11,
"94-AL1/15-ST1A 20.0",
name="sdhj",
parallel=3)
pp.create_switch(net, 3, 2, "l", name="dfdfg")
pp.create_switch(net, 4, 2, "l", False, name="dfhgj")
# check test grid
assert net.trafo.shape[0] == 1
assert net.line.shape[0] == 3
assert net.switch.shape[0] == 4
convert_parallel_branches(net)
# test parallelisation
assert net.trafo.shape[0] == 3
assert net.line.shape[0] == 6
assert net.switch.shape[0] == 11
net1 = deepcopy(net)
net1.switch.closed.loc[4] = False
convert_parallel_branches(net, multiple_entries=False)
convert_parallel_branches(net1, multiple_entries=False)
# test sum up of parallels
assert net.trafo.shape[0] == 1
assert net.line.shape[0] == 3
assert net.switch.shape[0] == 4
assert net1.trafo.shape[0] == 1
assert net1.line.shape[0] == 4
assert net1.switch.shape[0] == 5
def four_loads_with_branches_out():
"""
This function creates a simple ten bus system with four radial low voltage nodes connected to \
a medium valtage slack bus. At every of the four radial low voltage nodes another low voltage \
node with a load is connected via cable.
RETURN:
**net** - Returns the required four load system with branches
EXAMPLE:
import pandapower.networks as pn
net_four_load_with_branches = pn.four_loads_with_branches_out()
"""
pd_net = pp.create_empty_network()
busnr1 = pp.create_bus(pd_net, name="bus1ref", vn_kv=10.)
pp.create_ext_grid(pd_net, busnr1)
busnr2 = pp.create_bus(pd_net, name="bus2", vn_kv=.4)
pp.create_transformer(pd_net, busnr1, busnr2, std_type="0.25 MVA 10/0.4 kV")
busnr3 = pp.create_bus(pd_net, name="bus3", vn_kv=.4)
pp.create_line(pd_net, busnr2, busnr3, name="line1", length_km=0.05,
std_type="NAYY 4x120 SE")
busnr4 = pp.create_bus(pd_net, name="bus4", vn_kv=.4)
pp.create_line(pd_net, busnr3, busnr4, name="line2", length_km=0.05,
std_type="NAYY 4x120 SE")
busnr5 = pp.create_bus(pd_net, name="bus5", vn_kv=.4)
pp.create_line(pd_net, busnr4, busnr5, name="line3", length_km=0.05,
std_type="NAYY 4x120 SE")
busnr6 = pp.create_bus(pd_net, name="bus6", vn_kv=.4)
pp.create_line(pd_net, busnr5, busnr6, name="line4", length_km=0.05,
std_type="NAYY 4x120 SE")
busnr7 = pp.create_bus(pd_net, name="bus7", vn_kv=.4)
pp.create_line(pd_net, busnr3, busnr7, name="line5", length_km=0.05,
std_type="NAYY 4x120 SE")
busnr8 = pp.create_bus(pd_net, name="bus8", vn_kv=.4)
pp.create_line(pd_net, busnr4, busnr8, name="line6", length_km=0.05,
std_type="NAYY 4x120 SE")
busnr9 = pp.create_bus(pd_net, name="bus9", vn_kv=.4)
pp.create_line(pd_net, busnr5, busnr9, name="line7", length_km=0.05,
std_type="NAYY 4x120 SE")
busnr10 = pp.create_bus(pd_net, name="bus10", vn_kv=.4)
pp.create_line(pd_net, busnr6, busnr10, name="line8", length_km=0.05,
std_type="NAYY 4x120 SE")
pp.create_load(pd_net, busnr7, p_kw=30, q_kvar=10)
pp.create_load(pd_net, busnr8, p_kw=30, q_kvar=10)
pp.create_load(pd_net, busnr9, p_kw=30, q_kvar=10)
pp.create_load(pd_net, busnr10, p_kw=30, q_kvar=10)
return pd_net
def create_net1():
""" Create net from simple pandapower-OPF tutorial. """
net = pp.create_empty_network()
# create buses
bus1 = pp.create_bus(net, vn_kv=220.)
bus2 = pp.create_bus(net, vn_kv=110.)
bus3 = pp.create_bus(net, vn_kv=110.)
bus4 = pp.create_bus(net, vn_kv=110.)
# create 220/110 kV transformer
pp.create_transformer(net, bus1, bus2, std_type="100 MVA 220/110 kV")
# create 110 kV lines
pp.create_line(net,
bus2,
bus3,
length_km=70.,
std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net,
bus3,
bus4,
length_km=50.,
std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net,
bus4,
bus2,
length_km=40.,
std_type='149-AL1/24-ST1A 110.0')
# create loads
pp.create_load(net, bus2, p_mw=60, controllable=False)
pp.create_load(net, bus3, p_mw=70, controllable=False)
pp.create_load(net, bus4, p_mw=10, controllable=False)
# create generators
pp.create_ext_grid(net, bus1, min_p_mw=-1000, max_p_mw=1000)
pp.create_gen(net,
bus3,
p_mw=80,
min_p_mw=0,
max_p_mw=80,
vm_pu=1.01,
controllable=True)
pp.create_gen(net,
bus4,
p_mw=100,
min_p_mw=0,
max_p_mw=100,
vm_pu=1.01,
controllable=True)
return net
def test_tap_phase_shifter_default():
expected_default = False
net = pp.create_empty_network()
pp.create_bus(net, 110)
pp.create_bus(net, 20)
data = pp.load_std_type(net, "25 MVA 110/20 kV", "trafo")
if "tap_phase_shifter" in data:
del data["tap_phase_shifter"]
pp.create_std_type(net, data, "without_tap_shifter_info", "trafo")
pp.create_transformer_from_parameters(net, 0, 1, 25e3, 110, 20, 0.4, 12, 20, 0.07)
pp.create_transformer(net, 0, 1, "without_tap_shifter_info")
assert (net.trafo.tap_phase_shifter == expected_default).all()
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 ring_network():
net = pp.create_empty_network()
b0 = pp.create_bus(net, 220)
b1 = pp.create_bus(net, 110)
b2 = pp.create_bus(net, 110)
b3 = pp.create_bus(net, 110)
pp.create_ext_grid(net, b0, s_sc_max_mva=100., s_sc_min_mva=80., rx_min=0.4, rx_max=0.4)
pp.create_transformer(net, b0, b1, "100 MVA 220/110 kV")
pp.create_line(net, b1, b2, std_type="305-AL1/39-ST1A 110.0" , length_km=20.)
l2 = pp.create_line(net, b2, b3, std_type="N2XS(FL)2Y 1x185 RM/35 64/110 kV" , length_km=15.)
pp.create_line(net, b3, b1, std_type="N2XS(FL)2Y 1x185 RM/35 64/110 kV" , length_km=10.)
pp.create_switch(net, b3, l2, closed=False, et="l")
return net
def test_recycle_trafo(recycle_net):
# test trafo tap change
net = recycle_net
b4 = pp.create_bus(net, vn_kv=20.)
pp.create_transformer(net, 3, b4, std_type="0.4 MVA 10/0.4 kV")
net["trafo"].at[0, "tap_pos"] = 0
runpp_with_consistency_checks(net, recycle=dict(trafo=True, bus_pq=False, gen=False))
vm_pu = net.res_bus.at[b4, "vm_pu"]
net["trafo"].at[0, "tap_pos"] = 5
runpp_with_consistency_checks(net, recycle=dict(trafo=True, bus_pq=False, gen=False))
assert not np.allclose(vm_pu, net.res_bus.at[b4, "vm_pu"])
def meshed_network():
net = pp.create_empty_network("7bus_system")
# ext grid
b = []
b.append(pp.create_bus(net, vn_kv=380., name="exi", geodata=(0, 0)))
pp.create_ext_grid(net, b[0], name="exi")
# create 110kV buses
for i in range(1, 7):
b.append(
pp.create_bus(net, vn_kv=110., name="bus" + str(i),
geodata=(0, 0)))
# connect buses b1 to b6 with overhead lines
for i in range(1, 6):
l = pp.create_line(net,
b[i],
b[i + 1],
length_km=10. * i * 2.,
std_type="149-AL1/24-ST1A 110.0",
name="line" + str(i),
index=i + 2)
pp.create_switch(net,
b[i],
l,
et="l",
name="bl_switch_" + str(i),
index=i + 3)
# create trafo
pp.create_transformer(net,
hv_bus=b[0],
lv_bus=b[1],
std_type="160 MVA 380/110 kV",
name="trafo")
# create some more lines between b6-b1 and b1-b4
pp.create_line(net,
b[1],
b[4],
length_km=100.,
std_type="149-AL1/24-ST1A 110.0",
name="line6")
pp.create_line(net,
b[6],
b[1],
length_km=100.,
std_type="149-AL1/24-ST1A 110.0",
name="line7")
return net
def ring_network():
net = pp.create_empty_network()
b1 = pp.create_bus(net, 220)
b2 = pp.create_bus(net, 110)
b3 = pp.create_bus(net, 110)
b4 = pp.create_bus(net, 110)
pp.create_ext_grid(net, b1, s_sc_max_mva=100., s_sc_min_mva=80., rx_min=0.20, rx_max=0.35)
pp.create_transformer(net, b1, b2, "100 MVA 220/110 kV")
pp.create_line(net, b2, b3, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV", length_km=15.)
l2 = pp.create_line(net, b3, b4, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV", length_km=12.)
pp.create_line(net, b4, b2, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV", length_km=10.)
pp.create_switch(net, b4, l2, closed=False, et="l")
return net
def add_trafos(network, df=None, file=None):
"""
Add transformers to the specified network. Pass either a DataFrame or a pathstring to a csv-file.
Parameters
----------
network : pandapowerNet
PandaPower network representation.
df : DataFrame
DataFrame with bus characteristics.
file : str
Path to csv-file with transformer characteristics.
Return
------
net : pandapowerNet
PandaPower network representation with added transformers.
"""
# copy network
net = copy.deepcopy(network)
# load trafos
trafos = check_arguments(df, file)
# create dictonairy of busnames and busindices
busdict = dict(zip(net.bus.name, net.bus.index))
# parameter trafos
parameter_trafos = trafos[trafos.std_type.isna() == True]
for index, trafo in parameter_trafos.iterrows():
pp.create_transformer_from_parameters(net, name=trafo['name'], hv_bus=busdict[trafo.hv_bus],
lv_bus=busdict[trafo.lv_bus], sn_mva=trafo.sn_mva,
vn_hv_kv=trafo.vn_hv_kv, vn_lv_kv=trafo.vn_lv_kv,
vkr_percent=trafo.vkr_percent, vk_percent=trafo.vk_percent,
pfe_kw=trafo.pfe_kw, i0_percent=trafo.i0_percent,
in_service=trafo.in_service, parallel=trafo.parallel)
# default trafos
default_trafos = trafos[trafos.std_type.isna() == False]
for index, trafo in default_trafos.iterrows():
pp.create_transformer(net, name=trafo['name'], hv_bus=busdict[trafo.hv_bus],
lv_bus=busdict[trafo.lv_bus], std_type=trafo.std_type,
in_service=trafo.in_service, parallel=trafo.parallel)
return net
def simple_test_net():
net = pp.create_empty_network()
pp.set_user_pf_options(net, init='dc', calculate_voltage_angles=True)
b0 = pp.create_bus(net, 110)
b1 = pp.create_bus(net, 110)
b2 = pp.create_bus(net, 20)
b3 = pp.create_bus(net, 20)
b4 = pp.create_bus(net, 6)
pp.create_ext_grid(net, b0)
pp.create_line(net, b0, b1, 10, "149-AL1/24-ST1A 110.0")
pp.create_transformer(net, b1, b2, "25 MVA 110/20 kV", name='tr1')
pp.create_transformer3w_from_parameters(net,
b1,
b3,
b4,
110,
20,
6,
1e2,
1e2,
1e1,
3,
2,
2,
1,
1,
1,
100,
1,
60,
30,
'hv',
tap_step_percent=1.5,
tap_step_degree=0,
tap_pos=0,
tap_neutral=0,
tap_max=10,
tap_min=-10,
name='tr2')
pp.create_load(net, b2, 1.5e1, 1, name='trafo1')
pp.create_load(net, b3, 3e1, 1.5, name='trafo2_mv')
pp.create_load(net, b4, 2, -0.15, name='trafo2_lv')
return net
def test_drop_elements_at_buses():
net = pp.create_empty_network()
bus0 = pp.create_bus(net, vn_kv=110)
bus1 = pp.create_bus(net, vn_kv=20)
bus2 = pp.create_bus(net, vn_kv=10)
bus3 = pp.create_bus(net, vn_kv=0.4)
bus4 = pp.create_bus(net, vn_kv=0.4)
bus5 = pp.create_bus(net, vn_kv=20)
trafo0 = pp.create_transformer3w(net,
hv_bus=bus0,
mv_bus=bus1,
lv_bus=bus2,
name='trafo0',
std_type='63/25/38 MVA 110/20/10 kV')
trafo1 = pp.create_transformer(net,
hv_bus=bus2,
lv_bus=bus3,
std_type='0.4 MVA 10/0.4 kV')
line1 = pp.create_line(net,
from_bus=bus3,
to_bus=bus4,
length_km=20.1,
std_type='24-AL1/4-ST1A 0.4',
name='line1')
#switch0=pp.create_switch(net, bus = bus0, element = trafo0, et = 't3') #~~~~~ not implementable now
switch1 = pp.create_switch(net, bus=bus1, element=bus5, et='b')
switch2 = pp.create_switch(net, bus=bus2, element=trafo1, et='t')
switch3 = pp.create_switch(net, bus=bus3, element=line1, et='l')
# bus id needs to be entered as iterable, not done in the function
tb.drop_elements_at_buses(net, [bus5])
assert len(
net.switch
) == 2 # it should be 2 since switch is connected to bus5 but if we add "element" column for switch it would delete this
assert len(net.trafo) == 1
assert len(net.trafo3w) == 1
assert len(net.line) == 1
tb.drop_elements_at_buses(net, [bus4])
assert len(net.switch) == 1
assert len(net.line) == 0
assert len(net.trafo) == 1
assert len(net.trafo3w) == 1
tb.drop_elements_at_buses(net, [bus3])
assert len(net.switch) == 0
assert len(net.line) == 0
assert len(net.trafo) == 0
assert len(net.trafo3w) == 1
tb.drop_elements_at_buses(net, [bus2])
assert len(net.switch) == 0
assert len(net.line) == 0
assert len(net.trafo) == 0
assert len(net.trafo3w) == 0
tb.drop_elements_at_buses(net, [bus1])
assert len(net.switch) == 0
assert len(net.line) == 0
assert len(net.trafo) == 0
assert len(net.trafo3w) == 0
def test_next_bus():
net = pp.create_empty_network()
bus0 = pp.create_bus(net, vn_kv=110)
bus1 = pp.create_bus(net, vn_kv=20)
bus2 = pp.create_bus(net, vn_kv=10)
bus3 = pp.create_bus(net, vn_kv=0.4)
bus4 = pp.create_bus(net, vn_kv=0.4)
bus5 = pp.create_bus(net, vn_kv=20)
trafo0 = pp.create_transformer3w(net, hv_bus=bus0, mv_bus=bus1, lv_bus=bus2, name='trafo0',
std_type='63/25/38 MVA 110/20/10 kV')
trafo1 = pp.create_transformer(net, hv_bus=bus2, lv_bus=bus3, std_type='0.4 MVA 10/0.4 kV')
line1 = pp.create_line(net, from_bus=bus3, to_bus=bus4, length_km=20.1, std_type='24-AL1/4-ST1A 0.4', name='line1')
# switch0=pp.create_switch(net, bus = bus0, element = trafo0, et = 't3') #~~~~~ not implementable now
switch1 = pp.create_switch(net, bus=bus1, element=bus5, et='b')
switch2 = pp.create_switch(net, bus=bus2, element=trafo1, et='t')
switch3 = pp.create_switch(net, bus=bus3, element=line1, et='l')
# assert tb.next_bus(net,bus0,trafo0,et='trafo3w')==bus1 # not implemented in existing toolbox
# assert tb.next_bus(net,bus0,trafo0,et='trafo3w',choice_for_trafo3w='lv')==bus2 # not implemented in existing toolbox
assert tb.next_bus(net, bus1, switch1, et='switch') == bus5 # Switch with bus2bus connection
# assert not tb.next_bus(net,bus2,switch2,et='switch')==bus3 # Switch with bus2trafo connection:- gives trasformer id instead of bus id
assert tb.next_bus(net, bus2, trafo1, et='trafo') == bus3
# assert tb.next_bus(net,bus3,switch3,et='switch') ==bus4 # Switch with bus2line connection :- gives line id instead of bus id
assert tb.next_bus(net, bus3, line1, et='line') == bus4
def test_get_connected_buses():
net = pp.create_empty_network()
bus0 = pp.create_bus(net, vn_kv=110)
bus1 = pp.create_bus(net, vn_kv=20)
bus2 = pp.create_bus(net, vn_kv=10)
bus3 = pp.create_bus(net, vn_kv=0.4)
bus4 = pp.create_bus(net, vn_kv=0.4)
bus5 = pp.create_bus(net, vn_kv=20)
trafo0 = pp.create_transformer3w(net, hv_bus=bus0, mv_bus=bus1, lv_bus=bus2, std_type='63/25/38 MVA 110/20/10 kV')
trafo1 = pp.create_transformer(net, hv_bus=bus2, lv_bus=bus3, std_type='0.4 MVA 10/0.4 kV')
line1 = pp.create_line(net, from_bus=bus3, to_bus=bus4, length_km=20.1, std_type='24-AL1/4-ST1A 0.4')
switch0a = pp.create_switch(net, bus=bus0, element=trafo0, et='t3')
switch0b = pp.create_switch(net, bus=bus2, element=trafo0, et='t3')
switch1 = pp.create_switch(net, bus=bus1, element=bus5, et='b')
switch2 = pp.create_switch(net, bus=bus2, element=trafo1, et='t')
switch3 = pp.create_switch(net, bus=bus3, element=line1, et='l')
assert list(tb.get_connected_buses(net, [bus0])) == [bus1, bus2]
assert list(tb.get_connected_buses(net, [bus1])) == [bus0, bus2, bus5]
assert list(tb.get_connected_buses(net, [bus2])) == [bus0, bus1, bus3]
assert list(tb.get_connected_buses(net, [bus3])) == [bus2, bus4]
assert list(tb.get_connected_buses(net, [bus4])) == [bus3]
assert list(tb.get_connected_buses(net, [bus5])) == [bus1]
assert list(tb.get_connected_buses(net, [bus0, bus1])) == [bus2, bus5]
assert list(tb.get_connected_buses(net, [bus2, bus3])) == [bus0, bus1, bus4]
net.switch.loc[[switch0b, switch1, switch2, switch3], 'closed'] = False
assert list(tb.get_connected_buses(net, [bus0])) == [bus1]
assert list(tb.get_connected_buses(net, [bus1])) == [bus0]
assert list(tb.get_connected_buses(net, [bus3])) == []
assert list(tb.get_connected_buses(net, [bus4])) == []
def test_get_connected_buses():
net = pp.create_empty_network()
bus0 = pp.create_bus(net, vn_kv=110)
bus1 = pp.create_bus(net, vn_kv=20)
bus2 = pp.create_bus(net, vn_kv=10)
bus3 = pp.create_bus(net, vn_kv=0.4)
bus4 = pp.create_bus(net, vn_kv=0.4)
bus5 = pp.create_bus(net, vn_kv=20)
trafo0 = pp.create_transformer3w(net, hv_bus=bus0, mv_bus=bus1, lv_bus=bus2, name='trafo0',
std_type='63/25/38 MVA 110/20/10 kV')
trafo1 = pp.create_transformer(net, hv_bus=bus2, lv_bus=bus3, std_type='0.4 MVA 10/0.4 kV')
line1 = pp.create_line(net, from_bus=bus3, to_bus=bus4, length_km=20.1, std_type='24-AL1/4-ST1A 0.4', name='line1')
# switch0=pp.create_switch(net, bus = bus0, element = trafo0, et = 't3') #~~~~~ not implementable
switch1 = pp.create_switch(net, bus=bus1, element=bus5, et='b')
switch2 = pp.create_switch(net, bus=bus2, element=trafo1, et='t')
switch3 = pp.create_switch(net, bus=bus3, element=line1, et='l')
assert list(tb.get_connected_buses(net, [bus0])) == [bus1, bus2] # trafo3w has not been implemented in the function
assert list(tb.get_connected_buses(net, [bus1])) == [bus0, bus2,
bus5] # trafo3w has not been implemented in the function
assert list(tb.get_connected_buses(net, [bus2])) == [bus0, bus1,
bus3] # trafo3w has not been implemented in the function
assert list(tb.get_connected_buses(net, [bus3])) == [bus2, bus4]
assert list(tb.get_connected_buses(net, [bus4])) == [bus3]
assert list(tb.get_connected_buses(net, [bus5])) == [bus1]
assert list(tb.get_connected_buses(net, [bus0, bus1])) == [bus2, bus5]
assert list(tb.get_connected_buses(net, [bus2, bus3])) == [bus0, bus1, bus4]
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 test_volt_dep_load_at_inactive_bus():
# create empty net
net = pp.create_empty_network()
# create buses
bus1 = pp.create_bus(net, index=0, vn_kv=20., name="Bus 1")
bus2 = pp.create_bus(net, index=1, vn_kv=0.4, name="Bus 2")
bus3 = pp.create_bus(net, index=3, in_service=False, vn_kv=0.4, name="Bus 3")
bus4 = pp.create_bus(net, index=4, vn_kv=0.4, name="Bus 4")
bus4 = pp.create_bus(net, index=5, vn_kv=0.4, name="Bus 4")
# create bus elements
pp.create_ext_grid(net, bus=bus1, vm_pu=1.02, name="Grid Connection")
pp.create_load(net, bus=4, p_mw=0.1, q_mvar=0.05, name="Load3", const_i_percent=100)
pp.create_load(net, bus=5, p_mw=0.1, q_mvar=0.05, name="Load4")
# create branch elements
trafo = pp.create_transformer(net, hv_bus=bus1, lv_bus=bus2, std_type="0.4 MVA 20/0.4 kV",
name="Trafo")
line1 = pp.create_line(net, from_bus=1, to_bus=3, length_km=0.1, std_type="NAYY 4x50 SE",
name="Line")
line2 = pp.create_line(net, from_bus=1, to_bus=4, length_km=0.1, std_type="NAYY 4x50 SE",
name="Line")
line3 = pp.create_line(net, from_bus=1, to_bus=5, length_km=0.1, std_type="NAYY 4x50 SE",
name="Line")
pp.runpp(net)
assert not np.isnan(net.res_load.p_mw.at[1])
assert not np.isnan(net.res_bus.p_mw.at[5])
assert net.res_bus.p_mw.at[3] == 0
def test_create_switches():
net = pp.create_empty_network()
# standard
b1 = pp.create_bus(net, 110)
b2 = pp.create_bus(net, 110)
b3 = pp.create_bus(net, 15)
b4 = pp.create_bus(net, 15)
l1 = pp.create_line(net, b1, b2, length_km=1, std_type="48-AL1/8-ST1A 10.0")
t1 = pp.create_transformer(net, b2, b3, std_type='160 MVA 380/110 kV')
sw = pp.create_switches(net, buses=[b1, b2, b3], elements=[l1, t1, b4], et=["l", "t", "b"],
z_ohm=0., foo='aaa')
assert (net.switch.bus.at[0] == b1)
assert (net.switch.bus.at[1] == b2)
assert (net.switch.bus.at[2] == b3)
assert (net.switch.element.at[sw[0]] == l1)
assert (net.switch.element.at[sw[1]] == t1)
assert (net.switch.element.at[sw[2]] == b4)
assert (net.switch.et.at[0] == "l")
assert (net.switch.et.at[1] == "t")
assert (net.switch.et.at[2] == "b")
assert (net.switch.z_ohm.at[0] == 0)
assert (net.switch.z_ohm.at[1] == 0)
assert (net.switch.z_ohm.at[2] == 0)
assert (net.switch.foo.at[0] == 'aaa')
assert (net.switch.foo.at[1] == 'aaa')
assert (net.switch.foo.at[2] == 'aaa')
def create_net_with_bb_switch():
net = pp.create_empty_network()
bus1 = pp.create_bus(net, name="bus1", vn_kv=10.)
bus2 = pp.create_bus(net, name="bus2", vn_kv=10.)
bus3 = pp.create_bus(net, name="bus3", vn_kv=10.)
bus4 = pp.create_bus(net, name="bus4", vn_kv=10.)
bus5 = pp.create_bus(net, name="bus5", vn_kv=110.)
pp.create_line_from_parameters(net, bus1, bus2, 10, r_ohm_per_km=.59, x_ohm_per_km=.35, c_nf_per_km=10.1,
max_i_ka=1)
pp.create_transformer(net, bus5, bus1, std_type="40 MVA 110/10 kV")
pp.create_ext_grid(net, bus=bus5, vm_pu=1.0)
pp.create_load(net, bus1, p_mw=.350, q_mvar=.100)
pp.create_load(net, bus2, p_mw=.450, q_mvar=.100)
pp.create_load(net, bus3, p_mw=.250, q_mvar=.100)
pp.create_load(net, bus4, p_mw=.150, q_mvar=.100)
# Created bb switch
pp.create_switch(net, bus2, element=bus3, et='b')
pp.create_switch(net, bus1, element=bus4, et='b')
pp.runpp(net, calculate_voltage_angles=True)
pp.create_measurement(net, "v", "bus", r2(net.res_bus.vm_pu.iloc[bus1], .002), .002, element=bus1)
pp.create_measurement(net, "v", "bus", r2(net.res_bus.vm_pu.iloc[bus3], .002), .002, element=bus3)
pp.create_measurement(net, "v", "bus", r2(net.res_bus.vm_pu.iloc[bus5], .002), .002, element=bus5)
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[bus5], .002), .002, element=bus5)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[bus5], .002), .002, element=bus5)
# If measurement on the bus with bb-switch activated, it will incluence the results of the merged bus
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[bus4], .002), .002, element=bus4)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[bus4], .002), .002, element=bus4)
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[bus3], .001), .001, element=bus3)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[bus3], .001), .001, element=bus3)
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[bus2], .001), .001, element=bus2)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[bus2], .001), .001, element=bus2)
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[bus1], .001), .001, element=bus1)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[bus1], .001), .001, element=bus1)
pp.create_measurement(net, "p", "line", r2(net.res_line.p_from_mw.iloc[0], .002), .002, 0, side='from')
pp.create_measurement(net, "q", "line", r2(net.res_line.q_from_mvar.iloc[0], .002), .002, 0, side='from')
pp.create_measurement(net, "p", "trafo", r2(net.res_trafo.p_hv_mw.iloc[0], .001), .01,
side="hv", element=0)
pp.create_measurement(net, "q", "trafo", r2(net.res_trafo.q_hv_mvar.iloc[0], .001), .01,
side="hv", element=0)
return net
def test_minimize_active_power_curtailment():
net = pp.create_empty_network()
# create buses
bus1 = pp.create_bus(net, vn_kv=220.)
bus2 = pp.create_bus(net, vn_kv=110.)
bus3 = pp.create_bus(net, vn_kv=110.)
bus4 = pp.create_bus(net, vn_kv=110.)
# create 220/110 kV transformer
pp.create_transformer(net, bus1, bus2, std_type="100 MVA 220/110 kV")
# create 110 kV lines
pp.create_line(net, bus2, bus3, length_km=70., std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net, bus3, bus4, length_km=50., std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net, bus4, bus2, length_km=40., std_type='149-AL1/24-ST1A 110.0')
# create loads
pp.create_load(net, bus2, p_mw=60, controllable=False)
pp.create_load(net, bus3, p_mw=70, controllable=False)
pp.create_load(net, bus4, p_mw=10, controllable=False)
# create generators
pp.create_ext_grid(net, bus1)
pp.create_gen(net, bus3, p_mw=80, max_p_mw=80, min_p_mw=0, vm_pu=1.01,
controllable=True)
pp.create_gen(net, bus4, p_mw=0.1, max_p_mw=100, min_p_mw=0, vm_pu=1.01,
controllable=True)
net.trafo["max_loading_percent"] = 50
net.line["max_loading_percent"] = 50
net.bus["min_vm_pu"] = 1.0
net.bus["max_vm_pu"] = 1.02
pp.create_poly_cost(net, 0, "gen", cp1_eur_per_mw=-0.01)
pp.create_poly_cost(net, 1, "gen", cp1_eur_per_mw=-0.01)
pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=0)
pp.runopp(net, calculate_voltage_angles=True)
assert net["OPF_converged"]
assert allclose(net.res_bus.vm_pu.values, array([1., 1.00000149, 1.01998544, 1.01999628]),
atol=1e-5)
assert allclose(net.res_bus.va_degree.values, array([0., -0.7055226, 0.85974768, 2.24584537]),
atol=1e-3)
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.
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)
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)
n = busnr4 + 1
net.bus_geodata = DataFrame(array([[0] * n, range(0, -n, -1)]).T,
columns=['x', 'y'])
return net
def run_simulation(self,
active_load=0.1,
reactive_load=0.05) -> (float, float):
"""
Runs the Pandaspower simulation with 3 buses, a 0.4 MVA 20/0.4 kV transformer, and an external grid connection.
:param active_load: Grid active load in megawatts. Default is 0.1.
:param reactive_load: Grid reactive load in megawatts. Default is 0.05.
:return: Resulting active and reactive grid load.
"""
# fallback parameters
if not active_load:
active_load = 0.1
if not reactive_load:
reactive_load = 0.05
# create empty net
net = pp.create_empty_network()
# create buses
b1 = pp.create_bus(net, vn_kv=20., name="Bus 1")
b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2")
b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3")
# create bus elements
pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection")
pp.create_load(net,
bus=b3,
p_mw=active_load,
q_mvar=reactive_load,
name="Load")
# create branch elements
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")
pp.runpp(net)
self._active_load, self._reactive_load = net.res_load.p_mw[
0], net.res_load.q_mvar[0]
return self._active_load, self._reactive_load
def _opf_net():
net = pp.create_empty_network()
pp.create_bus(net, 20, min_vm_pu=0.85, max_vm_pu=1.15)
pp.create_buses(net, 3, 0.4, min_vm_pu=0.85, max_vm_pu=1.15)
pp.create_transformer(net, 0, 1, "0.25 MVA 20/0.4 kV")
pp.create_line(net, 1, 2, 1, "48-AL1/8-ST1A 0.4")
pp.create_ext_grid(net, 0)
pp.create_dcline(net,
1,
3,
-5,
1,
1,
1,
1.02,
max_p_kw=10,
min_q_from_kvar=-5,
min_q_to_kvar=-5,
max_q_from_kvar=5,
max_q_to_kvar=5)
pp.create_load(net,
2,
15,
controllable=True,
max_p_kw=25,
min_p_kw=0,
max_q_kvar=5,
min_q_kvar=-5)
pp.create_gen(net,
1,
-2,
1.002,
controllable=True,
max_p_kw=0,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_sgen(net,
2,
-1,
controllable=True,
max_p_kw=0,
min_p_kw=-3,
max_q_kvar=1,
min_q_kvar=-1)
return net
def _opf_net():
net = pp.create_empty_network()
pp.create_bus(net, 20, min_vm_pu=0.85, max_vm_pu=1.15)
pp.create_buses(net, 3, 0.4, min_vm_pu=0.85, max_vm_pu=1.15)
pp.create_transformer(net, 0, 1, "0.25 MVA 20/0.4 kV")
pp.create_line(net, 1, 2, 1, "48-AL1/8-ST1A 0.4")
pp.create_ext_grid(net, 0)
pp.create_dcline(net,
1,
3,
-5,
1,
1,
1,
1.02,
max_p_mw=0.01,
min_q_from_mvar=-.005,
min_q_to_mvar=-0.005,
max_q_from_mvar=.005,
max_q_to_mvar=.005)
pp.create_load(net,
bus=2,
p_mw=0.015,
controllable=True,
max_p_mw=0.025,
min_p_mw=0,
max_q_mvar=0.005,
min_q_mvar=-0.005)
pp.create_gen(net,
bus=1,
p_mw=0.002,
vm_pu=1.002,
controllable=True,
max_p_mw=0,
min_p_mw=-0.025,
max_q_mvar=0.025,
min_q_mvar=-0.025)
pp.create_sgen(net,
bus=2,
p_mw=0.001,
controllable=True,
max_p_mw=0.003,
min_p_mw=0,
max_q_mvar=.001,
min_q_mvar=-.001)
return net
def convert_to_3ph(net):
### update external grid
net.ext_grid["r0x0_max"] = 0.1
net.ext_grid["x0x_max"] = 1.0
net.ext_grid["s_sc_max_mva"] = 10000
net.ext_grid["s_sc_min_mva"] = 8000
net.ext_grid["rx_min"] = 0.1
net.ext_grid["rx_max"] = 0.1
### update transformer
net.trafo = net.trafo.head(0)
pp.create_std_type(net, {"sn_mva": 0.3, "vn_hv_kv": 20, "vn_lv_kv": 0.4, "vk_percent": 6,
"vkr_percent": 0.78125, "pfe_kw": 2.7, "i0_percent": 0.16875,
"shift_degree": 0, "vector_group": "YNyn",
"tap_side": "hv", "tap_neutral": 0, "tap_min": -2, "tap_max": 2,
"tap_step_degree": 0, "tap_step_percent": 2.5, "tap_phase_shifter": False,
"vk0_percent": 6, "vkr0_percent": 0.78125, "mag0_percent": 100,
"mag0_rx": 0., "si0_hv_partial": 0.9,},
"YNyn", "trafo")
pp.create_transformer(net, 0, 1, std_type="YNyn", parallel=1,tap_pos=0,
index=pp.get_free_id(net.trafo))
net.trafo.reset_index()
### add zero sequence for lines
net.line["r0_ohm_per_km"] = 0.0848
net.line["x0_ohm_per_km"] = 0.4649556
net.line["c0_nf_per_km"] = 230.6
### convert loads to asymmertric loads
for i in net.load.index:
row = net.load.loc[i]
phases = [0,0,0]
p = i % 3
phases[p] = 1
pp.create_asymmetric_load(net, row['bus'],
p_a_mw=row['p_mw']*phases[0], q_a_mvar=row['q_mvar']*phases[0],
p_b_mw=row['p_mw']*phases[1], q_b_mvar=row['q_mvar']*phases[1],
p_c_mw=row['p_mw']*phases[2], q_c_mvar=row['q_mvar']*phases[2],
sn_mva=row['sn_mva'])
net.load['p_mw'] = 0
net.load['q_mvar'] = 0
pp.add_zero_impedance_parameters(net)
return net
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 test_unsupplied_buses_with_switches():
net = pp.create_empty_network()
pp.create_buses(net, 8, 20)
pp.create_buses(net, 5, 0.4)
pp.create_ext_grid(net, 0)
pp.create_line(net, 0, 1, 1.2, "NA2XS2Y 1x185 RM/25 12/20 kV")
pp.create_switch(net, 0, 0, "l", closed=True)
pp.create_switch(net, 1, 0, "l", closed=False)
pp.create_line(net, 0, 2, 1.2, "NA2XS2Y 1x185 RM/25 12/20 kV")
pp.create_switch(net, 0, 1, "l", closed=False)
pp.create_switch(net, 2, 1, "l", closed=True)
pp.create_line(net, 0, 3, 1.2, "NA2XS2Y 1x185 RM/25 12/20 kV")
pp.create_switch(net, 0, 2, "l", closed=False)
pp.create_switch(net, 3, 2, "l", closed=False)
pp.create_line(net, 0, 4, 1.2, "NA2XS2Y 1x185 RM/25 12/20 kV")
pp.create_switch(net, 0, 3, "l", closed=True)
pp.create_switch(net, 4, 3, "l", closed=True)
pp.create_line(net, 0, 5, 1.2, "NA2XS2Y 1x185 RM/25 12/20 kV")
pp.create_switch(net, 0, 6, "b", closed=True)
pp.create_switch(net, 0, 7, "b", closed=False)
pp.create_transformer(net, 0, 8, "0.63 MVA 20/0.4 kV")
pp.create_switch(net, 0, 0, "t", closed=True)
pp.create_switch(net, 8, 0, "t", closed=False)
pp.create_transformer(net, 0, 9, "0.63 MVA 20/0.4 kV")
pp.create_switch(net, 0, 1, "t", closed=False)
pp.create_switch(net, 9, 1, "t", closed=True)
pp.create_transformer(net, 0, 10, "0.63 MVA 20/0.4 kV")
pp.create_switch(net, 0, 2, "t", closed=False)
pp.create_switch(net, 10, 2, "t", closed=False)
pp.create_transformer(net, 0, 11, "0.63 MVA 20/0.4 kV")
pp.create_switch(net, 0, 3, "t", closed=True)
pp.create_switch(net, 11, 3, "t", closed=True)
pp.create_transformer(net, 0, 12, "0.63 MVA 20/0.4 kV")
pp.create_buses(net, 2, 20)
pp.create_impedance(net, 0, 13, 1, 1, 10)
pp.create_impedance(net, 0, 14, 1, 1, 10, in_service=False)
ub = top.unsupplied_buses(net)
assert ub == {1, 2, 3, 7, 8, 9, 10, 14}
ub = top.unsupplied_buses(net, respect_switches=False)
assert ub == {14}
