df= pd.read_csv(r"C:\Users\Asus\Documents\GitHub\Gisele_MILP\cluster3_PS.csv")
grid= pd.read_csv(r"C:\Users\Asus\Documents\GitHub\Gisele_MILP\connections_output.csv")
SS=pd.DataFrame(df)
for i in SS.index:
if (df.loc[i]['Population'] == 0) | (df.loc[i]['PS'] == 1):
SS.drop(i,inplace=True)
##############################################
#creating Primary Substations
pp.create_bus(net, name = "110 kV bar", vn_kv =110, type='b', index=0, geodata=(840689.518725477973931,8509568.724492659792304))
pp.create_bus(net, name = "20 kV bar", vn_kv =20, type='b',index=grid.at[0,"id1"], geodata=(840689.518725477973931,8509568.724492659792304))
##############################################
#creating Secondary Substations
for i in SS.index:
pp.create_bus(net, vn_kv=20, type='b',index= SS.at[i,"id"], geodata=(SS.at[i,"X"], SS.at[i,"Y"]))
##############################################
#creating External Grid (Slack Bus)
pp.create_ext_grid(net, 0, vm_pu = 1)
##############################################
def test_opf_sgen_voltage():
""" Testing a simple network with transformer for voltage
constraints with OPF using a static generator """
# boundaries
vm_max = 1.04
vm_min = 0.96
# 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,
vsc_percent=3.75,
tp_max=2,
vn_lv_kv=0.4,
shift_degree=150,
tp_mid=0,
vn_hv_kv=10.0,
vscr_percent=2.8125,
tp_pos=0,
tp_side="hv",
tp_min=-2,
tp_st_percent=2.5,
i0_percent=0.68751,
sn_kva=16.0,
pfe_kw=0.11,
name=None,
in_service=True,
index=None,
max_loading_percent=1000000)
pp.create_sgen(net,
3,
p_kw=-10,
controllable=True,
max_p_kw=-5,
min_p_kw=-15,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_polynomial_cost(net, 0, "sgen", array([-100, 0]))
pp.create_ext_grid(net, 0)
pp.create_line_from_parameters(net,
1,
2,
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,
max_loading_percent=1000000)
pp.create_line_from_parameters(net,
2,
3,
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,
max_loading_percent=1000000)
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
# assert and check result
logger.debug("test_opf_sgen_voltage")
logger.debug("res_sgen:\n%s" % net.res_sgen)
logger.debug("res_bus.vm_pu: \n%s" % net.res_bus.vm_pu)
assert max(net.res_bus.vm_pu) < vm_max
assert min(net.res_bus.vm_pu) > vm_min
import pandapower as pp
import pandapower.networks
net = pp.create_empty_network()
#Network Buses (Note: A substation can have multiple buses)
bus1 = pp.create_bus(net, name="HV Busbar", vn_kv=110, type="b")
bus2 = pp.create_bus(net, name="HV Busbar 2", vn_kv=110, type="b")
bus3 = pp.create_bus(net, name="HV Transformer Bus", vn_kv=110, type="n")
bus4 = pp.create_bus(net, name="MV Transformer Bus", vn_kv=20, type="n")
bus5 = pp.create_bus(net, name="MV Main Bus", vn_kv=20, type="b")
bus6 = pp.create_bus(net, name="MV Bus 1", vn_kv=20, type="b")
bus7 = pp.create_bus(net, name="MV Bus 2", vn_kv=20, type="b")
#Adding Transformers to the Network
trafo1 = pp.create_transformer(net,
bus3,
bus4,
name="110kV/20kV transformer",
std_type="25 MVA 110/20 kV")
#Lines
line1 = pp.create_line(net,
bus1,
bus2,
length_km=10.0,
std_type="N2XS(FL)2Y 1x300 RM/35 64/110 kV")
line2 = pp.create_line(net,
bus5,
def example_simple():
"""
Returns the simple example network from the pandapower tutorials.
OUTPUT:
net - simple example network
EXAMPLE:
>>> import pandapower.networks
>>> net = pandapower.networks.example_simple()
"""
net = pp.create_empty_network()
# create buses
bus1 = pp.create_bus(net, name="HV Busbar", vn_kv=110., type="b")
bus2 = pp.create_bus(net, name="HV Busbar 2", vn_kv=110., type="b")
bus3 = pp.create_bus(net, name="HV Transformer Bus", vn_kv=110., type="n")
bus4 = pp.create_bus(net, name="MV Transformer Bus", vn_kv=20., type="n")
bus5 = pp.create_bus(net, name="MV Main Bus", vn_kv=20., type="b")
bus6 = pp.create_bus(net, name="MV Bus 1", vn_kv=20., type="b")
bus7 = pp.create_bus(net, name="MV Bus 2", vn_kv=20., type="b")
# create external grid
pp.create_ext_grid(net, bus1, vm_pu=1.02, va_degree=50)
# create transformer
pp.create_transformer(net,
bus3,
bus4,
name="110kV/20kV transformer",
std_type="25 MVA 110/20 kV")
# create lines
pp.create_line(net,
bus1,
bus2,
length_km=10,
std_type="N2XS(FL)2Y 1x300 RM/35 64/110 kV",
name="Line 1")
line2 = pp.create_line(net,
bus5,
bus6,
length_km=2.0,
std_type="NA2XS2Y 1x240 RM/25 12/20 kV",
name="Line 2")
line3 = pp.create_line(net,
bus6,
bus7,
length_km=3.5,
std_type="48-AL1/8-ST1A 20.0",
name="Line 3")
line4 = pp.create_line(net,
bus7,
bus5,
length_km=2.5,
std_type="NA2XS2Y 1x240 RM/25 12/20 kV",
name="Line 4")
# create bus-bus switches
pp.create_switch(net, bus2, bus3, et="b", type="CB")
pp.create_switch(net, bus4, bus5, et="b", type="CB")
# create bus-line switches
pp.create_switch(net, bus5, line2, et="l", type="LBS", closed=True)
pp.create_switch(net, bus6, line2, et="l", type="LBS", closed=True)
pp.create_switch(net, bus6, line3, et="l", type="LBS", closed=True)
pp.create_switch(net, bus7, line3, et="l", type="LBS", closed=False)
pp.create_switch(net, bus7, line4, et="l", type="LBS", closed=True)
pp.create_switch(net, bus5, line4, et="l", type="LBS", closed=True)
# create load
pp.create_load(net, bus7, p_mw=2, q_mvar=4, scaling=0.6, name="load")
# create generator
pp.create_gen(net,
bus6,
p_mw=6,
max_q_mvar=3,
min_q_mvar=-3,
vm_pu=1.03,
name="generator")
# create static generator
pp.create_sgen(net, bus7, p_mw=2, q_mvar=-0.5, name="static generator")
# create shunt
pp.create_shunt(net, bus3, q_mvar=-0.96, p_mw=0, name='Shunt')
return net
def test_pandapower_case():
# more complicated examples like
# net = pandapower.networks.example_simple()
# can be used once the import of e.g. switches is perfected
# create empty net
net = pp.create_empty_network()
# create buses
b1 = pp.create_bus(net, vn_kv=20.0, 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=0.1, q_mvar=0.05, 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")
# because of phase angles, need to init with DC
pp.runpp(net, calculate_voltage_angles=True, init="dc")
n = pypsa.Network()
n.import_from_pandapower_net(net)
# seed PF with LPF solution because of phase angle jumps
n.lpf()
n.pf(use_seed=True)
# use same index for everything
net.res_bus.index = net.bus.name.values
net.res_line.index = net.line.name.values
# compare bus angles
equal(n.buses_t.v_ang.loc["now"] * 180 / np.pi, net.res_bus.va_degree)
# compare bus voltage magnitudes
equal(n.buses_t.v_mag_pu.loc["now"], net.res_bus.vm_pu)
# compare bus active power (NB: pandapower uses load signs)
equal(n.buses_t.p.loc["now"], -net.res_bus.p_mw)
# compare bus active power (NB: pandapower uses load signs)
equal(n.buses_t.q.loc["now"], -net.res_bus.q_mvar)
# compare branch flows
equal(n.lines_t.p0.loc["now"], net.res_line.p_from_mw)
equal(n.lines_t.p1.loc["now"], net.res_line.p_to_mw)
equal(n.lines_t.q0.loc["now"], net.res_line.q_from_mvar)
equal(n.lines_t.q1.loc["now"], net.res_line.q_to_mvar)
equal(n.transformers_t.p0.loc["now"], net.res_trafo.p_hv_mw)
equal(n.transformers_t.p1.loc["now"], net.res_trafo.p_lv_mw)
equal(n.transformers_t.q0.loc["now"], net.res_trafo.q_hv_mvar)
equal(n.transformers_t.q1.loc["now"], net.res_trafo.q_lv_mvar)
def test_without_ext_grid():
net = pp.create_empty_network()
min_vm_pu = 0.95
max_vm_pu = 1.05
# create buses
bus1 = pp.create_bus(net, vn_kv=220., geodata=(5, 9))
bus2 = pp.create_bus(net, vn_kv=110., geodata=(6, 10), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
bus3 = pp.create_bus(net, vn_kv=110., geodata=(10, 9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
bus4 = pp.create_bus(net, vn_kv=110., geodata=(8, 8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
bus5 = pp.create_bus(net, vn_kv=110., geodata=(6, 8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
# create 220/110/110 kV 3W-transformer
pp.create_transformer3w_from_parameters(net, bus1, bus2, bus5, vn_hv_kv=220, vn_mv_kv=110,
vn_lv_kv=110, vk_hv_percent=10., vk_mv_percent=10.,
vk_lv_percent=10., vkr_hv_percent=0.5,
vkr_mv_percent=0.5, vkr_lv_percent=0.5, pfe_kw=100,
i0_percent=0.1, shift_mv_degree=0, shift_lv_degree=0,
sn_hv_mva=100, sn_mv_mva=50, sn_lv_mva=50)
# 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')
pp.create_line(net, bus4, bus5, length_km=30., 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
g1 = pp.create_gen(net, bus1, p_mw=40, min_p_mw=0, min_q_mvar=-20, max_q_mvar=20, slack=True, min_vm_pu=min_vm_pu,
max_vm_pu=max_vm_pu)
pp.create_poly_cost(net, g1, 'gen', cp1_eur_per_mw=1000)
g2 = pp.create_gen(net, bus3, p_mw=40, min_p_mw=0, min_q_mvar=-20, max_q_mvar=20, vm_pu=1.01,
min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu, max_p_mw=40.)
pp.create_poly_cost(net, g2, 'gen', cp1_eur_per_mw=2000)
g3 = pp.create_gen(net, bus4, p_mw=0.050, min_p_mw=0, min_q_mvar=-20, max_q_mvar=20, vm_pu=1.01,
min_vm_pu=min_vm_pu,
max_vm_pu=max_vm_pu, max_p_mw=0.05)
pp.create_poly_cost(net, g3, 'gen', cp1_eur_per_mw=3000)
pp.runpm_ac_opf(net)
consistency_checks(net, rtol=1e-3)
assert np.isclose(net.res_gen.p_mw.at[g2], 0, atol=1e-5, rtol=1e-5)
assert np.isclose(net.res_gen.p_mw.at[g3], 0, atol=1e-5, rtol=1e-5)
assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] * 1e3)
net.trafo3w["max_loading_percent"] = 150.
pp.runpm_ac_opf(net)
consistency_checks(net, rtol=1e-3)
assert 149. < net.res_trafo3w.loading_percent.values[0] < 150.01
assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] * 1e3 + net.res_gen.p_mw.at[g2] * 2e3)
pp.runpm_dc_opf(net)
consistency_checks(net, rtol=1e-3, test_q=False)
assert 149. < net.res_trafo3w.loading_percent.values[0] < 150.01
assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] * 1e3 + net.res_gen.p_mw.at[g2] * 2e3)
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 _create_empty_network_with_transformer(trafotype, V_OS=10., V_US=0.4):
"""
Creates a Network with transformer and infeeder. The reference bus on the \
high-voltage side is called "Trafostation_OS". The bus on the low-voltage \
side is called "main_busbar".
The voltage levels can be set manually and the transformer parameter can \
be set with "ti"
"""
pd_net = pp.create_empty_network()
NFA2X4x70 = {
"c_nf_per_km": 0,
"r_ohm_per_km": 0.443,
"x_ohm_per_km": 0.069,
"max_i_ka": 0.270,
"type": "ol",
"q_mm2": 70
}
NAYY4x50 = {
"c_nf_per_km": 670,
"r_ohm_per_km": 0.6417,
"x_ohm_per_km": 0.084823,
"max_i_ka": 0.141,
"type": "cs",
"q_mm2": 50
}
NAYY4x150 = {
"c_nf_per_km": 830,
"r_ohm_per_km": 0.2067,
"x_ohm_per_km": 0.08042478,
"max_i_ka": 0.275,
"type": "cs",
"q_mm2": 150
}
NAYY4x185 = {
"c_nf_per_km": 830,
"r_ohm_per_km": 0.165,
"x_ohm_per_km": 0.08042478,
"max_i_ka": 0.313,
"type": "cs",
"q_mm2": 185
}
NYY4x35 = {
"c_nf_per_km": 0,
"r_ohm_per_km": 0.5240284,
"x_ohm_per_km": 0.08513716,
"max_i_ka": 0.156,
"type": "cs",
"q_mm2": 35
}
pp.create_std_type(net=pd_net,
data=NFA2X4x70,
name="NFA2X 4x70",
element="line")
pp.create_std_type(net=pd_net,
data=NAYY4x50,
name="NAYY 4x50",
element="line")
pp.create_std_type(net=pd_net,
data=NAYY4x150,
name="NAYY 4x150",
element="line")
pp.create_std_type(net=pd_net,
data=NAYY4x185,
name="NAYY 4x185",
element="line")
pp.create_std_type(net=pd_net,
data=NYY4x35,
name="NYY 4x35",
element="line")
T100kVA = {
"sn_kva": 100,
"vn_hv_kv": 10,
"vn_lv_kv": 0.4,
"vsc_percent": 4,
"vscr_percent": 1.2,
"pfe_kw": 0.45,
"i0_percent": 0.25,
"shift_degree": 150,
"vector_group": "Dyn5"
}
T160kVA = {
"sn_kva": 160,
"vn_hv_kv": 10,
"vn_lv_kv": 0.4,
"vsc_percent": 4,
"vscr_percent": 1.2,
"pfe_kw": 0.38,
"i0_percent": 0.26,
"shift_degree": 150,
"vector_group": "Dyn5"
}
pp.create_std_type(net=pd_net,
data=T100kVA,
name="0.1 MVA 10/0.4 kV",
element="trafo")
pp.create_std_type(net=pd_net,
data=T160kVA,
name="0.16 MVA 10/0.4 kV",
element="trafo")
busnr1 = pp.create_bus(pd_net, name="Trafostation_OS", vn_kv=V_OS)
pp.create_ext_grid(pd_net, bus=busnr1)
main_busbar_nr = pp.create_bus(pd_net,
name="main_busbar",
vn_kv=V_US,
type="b")
pp.create_transformer(pd_net,
hv_bus=busnr1,
lv_bus=main_busbar_nr,
std_type=trafotype,
name="trafo 1")
return pd_net, main_busbar_nr
def test_4bus_network(init, recycle):
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, init=init, recycle=recycle)
runpp_3ph_with_consistency_checks(net, init=init, recycle=recycle)
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
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
if not np.allclose(
result, res_trafo_i_ka, atol=tolerances[trafo_vector_group]):
raise ValueError(
"Incorrect results for vector group %s" % trafo_vector_group,
res_trafo_i_ka, result)
def check_results(net, trafo_vector_group, results):
check_bus_voltages(net, results[0], trafo_vector_group)
check_line_currents(net, results[1], trafo_vector_group)
check_trafo_currents(net, results[2], trafo_vector_group)
def make_nw(net, bushv, tap_ps, case, vector_group):
b1 = pp.create_bus(net,
bushv,
zone=vector_group,
index=pp.get_free_id(net.bus))
b2 = pp.create_bus(net, 0.4, zone=vector_group)
b3 = pp.create_bus(net, 0.4, zone=vector_group)
pp.create_ext_grid(net,
b1,
s_sc_max_mva=10000,
rx_max=0.1,
r0x0_max=0.1,
x0x_max=1.0)
pp.create_transformer_from_parameters(net,
hv_bus=b1,
lv_bus=b2,
sn_mva=1.6,
vn_hv_kv=10,
vn_lv_kv=0.4,
def test_init_slack_with_multiple_transformers():
np.random.seed(123)
net = pp.create_empty_network()
pp.create_bus(net, 220, index=0)
pp.create_bus(net, 110, index=1)
pp.create_bus(net, 110, index=2)
pp.create_bus(net, 110, index=3)
pp.create_bus(net, 10, index=4)
pp.create_bus(net, 10, index=5)
pp.create_bus(net, 10, index=6)
pp.create_bus(net, 10, index=7, in_service=False)
pp.create_transformer(net,
3,
7,
std_type="63 MVA 110/10 kV",
in_service=False)
pp.create_transformer(net, 3, 4, std_type="63 MVA 110/10 kV")
pp.create_transformer(net, 0, 1, std_type="100 MVA 220/110 kV")
pp.create_line(net, 1, 2, 2.0, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV")
pp.create_line(net, 1, 3, 2.0, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV")
pp.create_line(net, 4, 5, 2.0, std_type="NA2XS2Y 1x95 RM/25 12/20 kV")
pp.create_line(net, 5, 6, 2.0, std_type="NA2XS2Y 1x95 RM/25 12/20 kV")
pp.create_load(net, 2, 5000, 3300)
pp.create_load(net, 5, 900, 500)
pp.create_load(net, 6, 700, 300)
pp.create_ext_grid(net,
bus=0,
vm_pu=1.04,
va_degree=10.,
name="Slack 220 kV")
pp.runpp(net)
for bus, row in net.res_bus[net.bus.in_service == True].iterrows():
pp.create_measurement(net, "v", "bus", row.vm_pu * r(0.01), 0.01, bus)
if row.p_kw != 0.:
continue
pp.create_measurement(net, "p", "bus", -row.p_kw * r(),
max(1.0, abs(0.03 * row.p_kw)), bus)
pp.create_measurement(net, "q", "bus", -row.q_kvar * r(),
max(1.0, abs(0.03 * row.q_kvar)), bus)
pp.create_measurement(net,
"p",
"line",
net.res_line.p_from_kw[0],
10.,
bus=1,
element=0)
pp.create_measurement(net,
"q",
"line",
net.res_line.q_from_kvar[0],
10.,
bus=1,
element=0)
pp.create_measurement(net,
"p",
"line",
net.res_line.p_from_kw[2],
10.,
bus=4,
element=2)
pp.create_measurement(net,
"q",
"line",
net.res_line.q_from_kvar[2],
10.,
bus=4,
element=2)
pp.create_measurement(net,
"p",
"line",
net.res_line.p_from_kw[3],
10.,
bus=5,
element=3)
pp.create_measurement(net,
"q",
"line",
net.res_line.q_from_kvar[3],
10.,
bus=5,
element=3)
success = estimate(net, init='slack')
diff_v = net.res_bus_est.vm_pu.values - np.asarray([
1.044860374, 1.0425606695, 1.0423765983, 1.0425110929, 1.0412160717,
1.0294819221, 1.0244679562, np.nan
])
diff_delta = net.res_bus_est.va_degree.values - np.asarray([
10., 9.5804972667, 9.5764432027, 9.5785762652, -140.5572134472,
-140.5248734844, -140.5280590882, np.nan
])
assert success
assert (np.nanmax(abs(diff_v)) < 1e-8)
assert (np.nanmax(abs(diff_delta)) < 1e-8)
def test_3bus():
# 1. Create network
net = pp.create_empty_network()
pp.create_ext_grid(net, 0)
pp.create_bus(net, name="bus1", vn_kv=1.)
pp.create_bus(net, name="bus2", vn_kv=1.)
pp.create_bus(net, name="bus3", vn_kv=1.)
pp.create_line_from_parameters(net,
0,
1,
1,
r_ohm_per_km=0.7,
x_ohm_per_km=0.2,
c_nf_per_km=0,
max_i_ka=1)
pp.create_line_from_parameters(net,
0,
2,
1,
r_ohm_per_km=0.8,
x_ohm_per_km=0.8,
c_nf_per_km=0,
max_i_ka=1)
pp.create_line_from_parameters(net,
1,
2,
1,
r_ohm_per_km=1,
x_ohm_per_km=0.6,
c_nf_per_km=0,
max_i_ka=1)
pp.create_measurement(net,
"p",
"line",
-0.0011e3,
0.01e3,
bus=0,
element=0) # p12
pp.create_measurement(net, "q", "line", 0.024e3, 0.01e3, bus=0,
element=0) # q12
pp.create_measurement(net, "p", "bus", 0.018e3, 0.01e3, bus=2) # p3
pp.create_measurement(net, "q", "bus", -0.1e3, 0.01e3, bus=2) # q3
pp.create_measurement(net, "v", "bus", 1.08, 0.05, 0) # u1
pp.create_measurement(net, "v", "bus", 1.015, 0.05, 2) # u3
# 2. Do state estimation
success = estimate(net, init='flat')
v_result = net.res_bus_est.vm_pu.values
delta_result = net.res_bus_est.va_degree.values
target_v = np.array([1.0627, 1.0589, 1.0317])
diff_v = target_v - v_result
target_delta = np.array([0., 0.8677, 3.1381])
diff_delta = target_delta - delta_result
assert success
assert (np.nanmax(abs(diff_v)) < 1e-4)
assert (np.nanmax(abs(diff_delta)) < 1e-4)
def test_3bus_with_2_slacks():
# load the net which already contains 3 buses
net = load_3bus_network()
# add the same net with different slack (no galvanic connection)
# skip bus index 4 as further stability test
pp.create_ext_grid(net, 5)
pp.create_bus(net, name="bus5", vn_kv=1., index=5)
pp.create_bus(net, name="bus6", vn_kv=1., index=6)
pp.create_bus(net, name="bus7", vn_kv=1., index=7)
pp.create_line_from_parameters(net,
5,
6,
1,
r_ohm_per_km=.01,
x_ohm_per_km=.03,
c_nf_per_km=0.,
max_i_ka=1)
pp.create_line_from_parameters(net,
5,
7,
1,
r_ohm_per_km=.02,
x_ohm_per_km=.05,
c_nf_per_km=0.,
max_i_ka=1)
pp.create_line_from_parameters(net,
6,
7,
1,
r_ohm_per_km=.03,
x_ohm_per_km=.08,
c_nf_per_km=0.,
max_i_ka=1)
pp.create_measurement(net, "v", "bus", 1.006, .004, bus=5) # V at bus 5
pp.create_measurement(net, "v", "bus", .968, .004, bus=6) # V at bus 6
pp.create_measurement(net, "p", "bus", -501, 10, 6) # P at bus 6
pp.create_measurement(net, "q", "bus", -286, 10, 6) # Q at bus 6
pp.create_measurement(net, "p", "line", 888, 8, 5,
3) # Pline (bus 1 -> bus 2) at bus 5
pp.create_measurement(net, "p", "line", 1173, 8, 5,
4) # Pline (bus 1 -> bus 3) at bus 5
pp.create_measurement(net, "q", "line", 568, 8, 5,
3) # Qline (bus 1 -> bus 2) at bus 5
pp.create_measurement(net, "q", "line", 663, 8, 5,
4) # Qline (bus 1 -> bus 3) at bus 5
# 2. Do state estimation
success = estimate(net, init='flat', maximum_iterations=10)
v_result = net.res_bus_est.vm_pu.values
delta_result = net.res_bus_est.va_degree.values
target_v = np.array(
[0.9996, 0.9741, 0.9438, np.nan, 0.9996, 0.9741, 0.9438])
diff_v = target_v - v_result
target_delta = np.array([
0.0, -1.2475469989322963, -2.7457167371166862, np.nan, 0.0,
-1.2475469989322963, -2.7457167371166862
])
diff_delta = target_delta - delta_result
assert success
assert (np.nanmax(abs(diff_v)) < 1e-4)
assert (np.nanmax(abs(diff_delta)) < 1e-4)
def test_pwl():
net = pp.create_empty_network()
# create buses
bus1 = pp.create_bus(net, vn_kv=110., min_vm_pu=0.9, max_vm_pu=1.1)
bus2 = pp.create_bus(net, vn_kv=110., min_vm_pu=0.9, max_vm_pu=1.1)
bus3 = pp.create_bus(net, vn_kv=110., min_vm_pu=0.9, max_vm_pu=1.1)
# create 110 kV lines
pp.create_line(net,
bus1,
bus2,
length_km=50.,
std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net,
bus2,
bus3,
length_km=50.,
std_type='149-AL1/24-ST1A 110.0')
# create loads
pp.create_load(net, bus2, p_mw=80, controllable=False)
# create generators
g1 = pp.create_gen(net,
bus1,
p_mw=80,
min_p_mw=0,
max_p_mw=80,
vm_pu=1.01,
slack=True)
g2 = pp.create_gen(net, bus3, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01)
# net.gen["controllable"] = False
pp.create_pwl_cost(net, g1, 'gen', [[0, 2, 2], [2, 80, 5]])
pp.create_pwl_cost(net, g2, 'gen', [[0, 2, 2], [2, 80, 5]])
pp.runpm_ac_opf(net)
consistency_checks(net, rtol=1e-3)
assert np.isclose(net.res_gen.p_mw.iloc[0], net.res_gen.p_mw.iloc[1])
assert np.isclose(net.res_gen.q_mvar.iloc[0], net.res_gen.q_mvar.iloc[1])
net.pwl_cost.drop(net.pwl_cost.index, inplace=True)
g3 = pp.create_gen(net, bus1, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01)
pp.create_pwl_cost(net, g1, 'gen', [[0, 2, 1.], [2, 80, 8.]])
pp.create_pwl_cost(net, g2, 'gen', [[0, 3, 2.], [3, 80, 14]])
pp.create_pwl_cost(net, g3, 'gen', [[0, 1, 3.], [1, 80, 10.]])
net.load.p_mw = 1
pp.runpm_ac_opf(net)
consistency_checks(net, rtol=1e-3)
assert np.isclose(net.res_gen.p_mw.at[g2], 0)
assert np.isclose(net.res_gen.p_mw.at[g3], 0)
assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1])
net.load.p_mw = 3
pp.runpm_ac_opf(net)
consistency_checks(net, rtol=1e-3)
assert np.isclose(net.res_gen.p_mw.at[g3], 0)
assert np.isclose(net.res_gen.p_mw.at[g1], 2)
assert np.isclose(net.res_cost,
net.res_gen.p_mw.at[g1] + net.res_gen.p_mw.at[g2] * 2)
net.load.p_mw = 5
pp.runpm_ac_opf(net)
consistency_checks(net, rtol=1e-3)
assert np.isclose(net.res_gen.p_mw.at[g1], 2)
assert np.isclose(net.res_gen.p_mw.at[g2], 3)
assert np.isclose(
net.res_cost, net.res_gen.p_mw.at[g1] + net.res_gen.p_mw.at[g2] * 2 +
net.res_gen.p_mw.at[g3] * 3)
# -*- coding: utf-8 -*- """ Created on Wed May 30 13:37:56 2018 @author: uoa-student2 """ import pandapower as pp from numpy import array net = pp.create_empty_network() #create buses bus1 = pp.create_bus(net, vn_kv=220., min_vm_pu=1.0, max_vm_pu=1.02) bus2 = pp.create_bus(net, vn_kv=110., min_vm_pu=1.0, max_vm_pu=1.02) bus3 = pp.create_bus(net, vn_kv=110., min_vm_pu=1.0, max_vm_pu=1.02) bus4 = pp.create_bus(net, vn_kv=110., min_vm_pu=1.0, max_vm_pu=1.02) bus = net.bus #create 220/110 kV transformer pp.create_transformer(net, bus1, bus2, std_type="100 MVA 220/110 kV", max_loading_percent=50) trafo = net.trafo #create 110 kV lines pp.create_line(net, bus2, bus3, length_km=70., std_type='149-AL1/24-ST1A 110.0', max_loading_percent=50) pp.create_line(net, bus3, bus4, length_km=50., std_type='149-AL1/24-ST1A 110.0', max_loading_percent=50) pp.create_line(net, bus4, bus2, length_km=40., std_type='149-AL1/24-ST1A 110.0', max_loading_percent=50) line = net.line #create loads pp.create_load(net, bus2, p_kw=60e3, controllable = False)
def net_3w_trafo_opf():
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.)
bus5 = pp.create_bus(net, vn_kv=110.)
pp.create_bus(net, vn_kv=110., in_service=False)
# create 220/110 kV transformer
pp.create_transformer3w_from_parameters(net,
bus1,
bus2,
bus5,
vn_hv_kv=220,
vn_mv_kv=110,
vn_lv_kv=110,
vk_hv_percent=10.,
vk_mv_percent=10.,
vk_lv_percent=10.,
vkr_hv_percent=0.5,
vkr_mv_percent=0.5,
vkr_lv_percent=0.5,
pfe_kw=100,
i0_percent=0.1,
shift_mv_degree=0,
shift_lv_degree=0,
sn_hv_mva=100,
sn_mv_mva=50,
sn_lv_mva=50)
# 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')
pp.create_line(net,
bus4,
bus5,
length_km=30.,
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_sgen(net, bus3, p_mw=10, controllable=False)
# create generators
pp.create_ext_grid(net,
bus1,
min_p_mw=0,
max_p_mw=1000,
max_q_mvar=0.01,
min_q_mvar=0)
pp.create_gen(net, bus3, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01)
pp.create_gen(net, bus4, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01)
net.gen["controllable"] = False
return net
def _add_lines_with_branched_loads(net,
n_lines,
startbus,
length_per_line,
std_type="NAYY 4x150 SE",
p_per_load_in_kw=0,
q_per_load_in_kvar=0,
length_branchout_line_1=0.022,
length_branchout_line_2=0,
std_type_branchout_line_1="NAYY 4x50 SE",
std_type_branchout_line_2="NAYY 4x50 SE",
prob_branchout_line_1=0.5,
branchnr=1):
"""
Creates a single unsplitted branch on the startbus. each bus on the main \
line is connected to a branch out line which connects \
the loadbus (households).
If there are two std_types given for the branch_out_lin. The cable_types \
interchange with the given probability
If there are two lengths of branchoutlines are given, the \
lengths interchange.
It begins with length 1 and switches to length 2. The cable with length 1 \
is named as "MUF_" and length 2 becomes "KV_".
Loads will only be added if p_per_load_in_kw or q_per_load_in_kvar \
is assigned
The branch number could be assigned with branchnr. It will be added to the\
name ti keep track on the node position
"""
# support function
startpoint_bus = 1
startpoint_line = 1
bus_before = startbus
length_branchout_line = length_branchout_line_1
# destinct between Muffe und Kabelverteiler
if length_branchout_line_2:
bustype = "MUF"
else:
bustype = "bus"
std_type_branchout_line = std_type_branchout_line_1
for i in range(n_lines):
buscounter = startpoint_bus + i
linecounter = startpoint_line + i
created_bus_nr = pp.create_bus(net,
name="%s_%d_%d" %
(bustype, branchnr, buscounter),
type="b" if bustype == "KV" else "n",
vn_kv=.4)
pp.create_line(net,
bus_before,
created_bus_nr,
length_km=length_per_line,
name="line_%d_%d" % (branchnr, linecounter),
std_type=std_type)
loadbusnr = pp.create_bus(net,
name="loadbus_%d_%d" %
(branchnr, buscounter),
vn_kv=.4)
pp.create_line(net,
created_bus_nr,
loadbusnr,
length_km=length_branchout_line,
name="branchout_line_%d_%d" % (branchnr, linecounter),
std_type=std_type_branchout_line)
if p_per_load_in_kw or q_per_load_in_kvar:
pp.create_load(net,
loadbusnr,
p_kw=p_per_load_in_kw,
q_kvar=q_per_load_in_kvar)
bus_before = created_bus_nr # rueckgefuehrter Wert in der Schleife
# alternates the lenght of the branch out lines if needed
if length_branchout_line_2:
if length_branchout_line == length_branchout_line_1:
length_branchout_line = length_branchout_line_2
bustype = "KV"
else:
length_branchout_line = length_branchout_line_1
bustype = "MUF"
# changes branch out lines according to the probabillity if needed
if std_type_branchout_line_2:
if rd.random() > prob_branchout_line_1:
std_type_branchout_line = std_type_branchout_line_2
else:
std_type_branchout_line = std_type_branchout_line_1
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=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_cost_piecewise_linear_gen_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_gen(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)
with pytest.raises(ValueError):
pp.create_piecewise_linear_cost(net,
0,
"gen",
np.array([[0, 0], [1, 50], [2, 100]]),
type="q")
with pytest.raises(ValueError):
pp.create_piecewise_linear_cost(net,
0,
"gen",
np.array([[0, 0], [-1, 50], [-2,
100]]),
type="q")
with pytest.raises(ValueError):
pp.create_piecewise_linear_cost(net,
0,
"gen",
np.array([[-10, 0], [-200, 50],
[-50, 100]]),
type="q")
pp.create_piecewise_linear_cost(net,
0,
"gen",
np.array([[-50, 50], [0, 0], [50, -50]]),
type="q")
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost - net.res_ext_grid.q_kvar.values < 1e-3
def tnep_grid():
net = pp.create_empty_network()
min_vm_pu = 0.95
max_vm_pu = 1.05
# create buses
bus1 = pp.create_bus(net,
vn_kv=110.,
geodata=(5, 9),
min_vm_pu=min_vm_pu,
max_vm_pu=max_vm_pu)
bus2 = pp.create_bus(net,
vn_kv=110.,
geodata=(6, 10),
min_vm_pu=min_vm_pu,
max_vm_pu=max_vm_pu)
bus3 = pp.create_bus(net,
vn_kv=110.,
geodata=(10, 9),
min_vm_pu=min_vm_pu,
max_vm_pu=max_vm_pu)
bus4 = pp.create_bus(net,
vn_kv=110.,
geodata=(8, 8),
min_vm_pu=min_vm_pu,
max_vm_pu=max_vm_pu)
# create 110 kV lines
pp.create_line(net,
bus1,
bus2,
length_km=70.,
std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net,
bus1,
bus3,
length_km=50.,
std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net,
bus1,
bus4,
length_km=100.,
std_type='149-AL1/24-ST1A 110.0')
# create loads
pp.create_load(net, bus2, p_mw=60)
pp.create_load(net, bus3, p_mw=70)
pp.create_load(net, bus4, p_mw=50)
# create generators
g1 = pp.create_gen(net,
bus1,
p_mw=9.513270,
min_p_mw=0,
max_p_mw=200,
vm_pu=1.01,
slack=True)
pp.create_poly_cost(net, g1, 'gen', cp1_eur_per_mw=1)
g2 = pp.create_gen(net,
bus2,
p_mw=78.403291,
min_p_mw=0,
max_p_mw=200,
vm_pu=1.01)
pp.create_poly_cost(net, g2, 'gen', cp1_eur_per_mw=3)
g3 = pp.create_gen(net,
bus3,
p_mw=92.375601,
min_p_mw=0,
max_p_mw=200,
vm_pu=1.01)
pp.create_poly_cost(net, g3, 'gen', cp1_eur_per_mw=3)
net.line["max_loading_percent"] = 20
# possible new lines (set out of service in line DataFrame)
l1 = pp.create_line(net,
bus1,
bus4,
10.,
std_type="305-AL1/39-ST1A 110.0",
name="new_line1",
max_loading_percent=20.,
in_service=False)
l2 = pp.create_line(net,
bus2,
bus4,
20.,
std_type="149-AL1/24-ST1A 110.0",
name="new_line2",
max_loading_percent=20.,
in_service=False)
l3 = pp.create_line(net,
bus3,
bus4,
30.,
std_type='149-AL1/24-ST1A 110.0',
name="new_line3",
max_loading_percent=20.,
in_service=False)
l4 = pp.create_line(net,
bus3,
bus4,
40.,
std_type='149-AL1/24-ST1A 110.0',
name="new_line4",
max_loading_percent=20.,
in_service=False)
new_line_index = [l1, l2, l3, l4]
construction_costs = [10., 20., 30., 45.]
# create new line dataframe
init_ne_line(net, new_line_index, construction_costs)
return net
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,
vsc_percent=3.75,
tp_max=2,
vn_lv_kv=0.4,
shift_degree=150,
tp_mid=0,
vn_hv_kv=10.0,
vscr_percent=2.8125,
tp_pos=0,
tp_side="hv",
tp_min=-2,
tp_st_percent=2.5,
i0_percent=0.68751,
sn_kva=16.0,
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_kw=10, q_kvar=0, name="load1")
pp.create_load(net, b3, p_kw=40, q_kvar=2, name="load2")
pp.create_gen(net, b4, p_kw=-200., vm_pu=1.0)
pp.create_sgen(net, b3, p_kw=-50, sn_kva=100)
return net
def create_cigre_network_mv(with_der=False):
net_cigre_mv = pp.create_empty_network()
# Linedata
line_data = {'c_nf_per_km': 151.1749, 'r_ohm_per_km': 0.501,
'x_ohm_per_km': 0.716, 'imax_ka': 0.145,
'type': 'cs'}
pp.create_std_type(net_cigre_mv, line_data, name='CABLE_CIGRE_MV', element='line')
line_data = {'c_nf_per_km': 10.09679, 'r_ohm_per_km': 0.510,
'x_ohm_per_km': 0.366, 'imax_ka': 0.195,
'type': 'ol'}
pp.create_std_type(net_cigre_mv, line_data, name='OHL_CIGRE_MV', element='line')
# Busses
bus0 = pp.create_bus(net_cigre_mv, name='Bus 0', vn_kv=110, type='b', zone='CIGRE_MV')
bus1 = pp.create_bus(net_cigre_mv, name='Bus 1', vn_kv=20, type='b', zone='CIGRE_MV')
bus2 = pp.create_bus(net_cigre_mv, name='Bus 2', vn_kv=20, type='b', zone='CIGRE_MV')
bus3 = pp.create_bus(net_cigre_mv, name='Bus 3', vn_kv=20, type='b', zone='CIGRE_MV')
bus4 = pp.create_bus(net_cigre_mv, name='Bus 4', vn_kv=20, type='b', zone='CIGRE_MV')
bus5 = pp.create_bus(net_cigre_mv, name='Bus 5', vn_kv=20, type='b', zone='CIGRE_MV')
bus6 = pp.create_bus(net_cigre_mv, name='Bus 6', vn_kv=20, type='b', zone='CIGRE_MV')
bus7 = pp.create_bus(net_cigre_mv, name='Bus 7', vn_kv=20, type='b', zone='CIGRE_MV')
bus8 = pp.create_bus(net_cigre_mv, name='Bus 8', vn_kv=20, type='b', zone='CIGRE_MV')
bus9 = pp.create_bus(net_cigre_mv, name='Bus 9', vn_kv=20, type='b', zone='CIGRE_MV')
bus10 = pp.create_bus(net_cigre_mv, name='Bus 10', vn_kv=20, type='b', zone='CIGRE_MV')
bus11 = pp.create_bus(net_cigre_mv, name='Bus 11', vn_kv=20, type='b', zone='CIGRE_MV')
bus12 = pp.create_bus(net_cigre_mv, name='Bus 12', vn_kv=20, type='b', zone='CIGRE_MV')
bus13 = pp.create_bus(net_cigre_mv, name='Bus 13', vn_kv=20, type='b', zone='CIGRE_MV')
bus14 = pp.create_bus(net_cigre_mv, name='Bus 14', vn_kv=20, type='b', zone='CIGRE_MV')
# Lines
pp.create_line(net_cigre_mv, bus1, bus2, length_km=2.82,
std_type='CABLE_CIGRE_MV', name='Line 1-2')
pp.create_line(net_cigre_mv, bus2, bus3, length_km=4.42,
std_type='CABLE_CIGRE_MV', name='Line 2-3')
pp.create_line(net_cigre_mv, bus3, bus4, length_km=0.61,
std_type='CABLE_CIGRE_MV', name='Line 3-4')
pp.create_line(net_cigre_mv, bus4, bus5, length_km=0.56,
std_type='CABLE_CIGRE_MV', name='Line 4-5')
pp.create_line(net_cigre_mv, bus5, bus6, length_km=1.54,
std_type='CABLE_CIGRE_MV', name='Line 5-6')
pp.create_line(net_cigre_mv, bus7, bus8, length_km=1.67,
std_type='CABLE_CIGRE_MV', name='Line 7-8')
pp.create_line(net_cigre_mv, bus8, bus9, length_km=0.32,
std_type='CABLE_CIGRE_MV', name='Line 8-9')
pp.create_line(net_cigre_mv, bus9, bus10, length_km=0.77,
std_type='CABLE_CIGRE_MV', name='Line 9-10')
pp.create_line(net_cigre_mv, bus10, bus11, length_km=0.33,
std_type='CABLE_CIGRE_MV', name='Line 10-11')
pp.create_line(net_cigre_mv, bus3, bus8, length_km=1.3,
std_type='CABLE_CIGRE_MV', name='Line 3-8')
pp.create_line(net_cigre_mv, bus12, bus13, length_km=4.89,
std_type='OHL_CIGRE_MV', name='Line 12-13')
pp.create_line(net_cigre_mv, bus13, bus14, length_km=2.99,
std_type='OHL_CIGRE_MV', name='Line 13-14')
line6_7 = pp.create_line(net_cigre_mv, bus6, bus7, length_km=0.24,
std_type='CABLE_CIGRE_MV', name='Line 6-7')
line4_11 = pp.create_line(net_cigre_mv, bus11, bus4, length_km=0.49,
std_type='CABLE_CIGRE_MV', name='Line 11-4')
line8_14 = pp.create_line(net_cigre_mv, bus14, bus8, length_km=2.,
std_type='OHL_CIGRE_MV', name='Line 14-8')
# Ext-Grid
pp.create_ext_grid(net_cigre_mv, bus0, vm_pu=1.03, va_degree=0.,
s_sc_max_mva=5000, s_sc_min_mva=5000, rx_max=0.1, rx_min=0.1)
# Trafos
trafo0 = pp.create_transformer_from_parameters(net_cigre_mv, bus0, bus1, sn_kva=25000,
vn_hv_kv=110, vn_lv_kv=20, vscr_percent=0.16,
vsc_percent=12.00107, pfe_kw=0, i0_percent=0,
shift_degree=30.0, name='Trafo 0-1')
trafo1 = pp.create_transformer_from_parameters(net_cigre_mv, bus0, bus12, sn_kva=25000,
vn_hv_kv=110, vn_lv_kv=20, vscr_percent=0.16,
vsc_percent=12.00107, pfe_kw=0, i0_percent=0,
shift_degree=30.0, name='Trafo 0-12')
# Switches
# S2
pp.create_switch(net_cigre_mv, bus6, line6_7, et='l', closed=True, type='LBS')
pp.create_switch(net_cigre_mv, bus7, line6_7, et='l', closed=False, type='LBS', name='S2')
# S3
pp.create_switch(net_cigre_mv, bus4, line4_11, et='l', closed=False, type='LBS', name='S3')
pp.create_switch(net_cigre_mv, bus11, line4_11, et='l', closed=True, type='LBS')
# S1
pp.create_switch(net_cigre_mv, bus8, line8_14, et='l', closed=False, type='LBS', name='S1')
pp.create_switch(net_cigre_mv, bus14, line8_14, et='l', closed=True, type='LBS')
# trafos
pp.create_switch(net_cigre_mv, bus0, trafo0, et='t', closed=True, type='CB')
pp.create_switch(net_cigre_mv, bus0, trafo1, et='t', closed=True, type='CB')
# Loads
# Residential
pp.create_load(net_cigre_mv, bus1, p_kw=14994.0, q_kvar=3044.66156, name='Load R1')
pp.create_load(net_cigre_mv, bus3, p_kw=276.45, q_kvar=69.28490, name='Load R3')
pp.create_load(net_cigre_mv, bus4, p_kw=431.65, q_kvar=108.18169, name='Load R4')
pp.create_load(net_cigre_mv, bus5, p_kw=727.5, q_kvar=182.32869, name='Load R5')
pp.create_load(net_cigre_mv, bus6, p_kw=548.05, q_kvar=137.35428, name='Load R6')
pp.create_load(net_cigre_mv, bus8, p_kw=586.85, q_kvar=147.07847, name='Load R8')
pp.create_load(net_cigre_mv, bus10, p_kw=475.3, q_kvar=119.12141, name='Load R10')
pp.create_load(net_cigre_mv, bus11, p_kw=329.8, q_kvar=82.65567, name='Load R11')
pp.create_load(net_cigre_mv, bus12, p_kw=14994.0, q_kvar=3044.66156, name='Load R12')
pp.create_load(net_cigre_mv, bus14, p_kw=208.55, q_kvar=52.26756, name='Load R14')
# Commercial / Industrial
pp.create_load(net_cigre_mv, bus1, p_kw=4845.0, q_kvar=1592.47449, name='Load CI1')
pp.create_load(net_cigre_mv, bus3, p_kw=225.25, q_kvar=139.59741, name='Load CI3')
pp.create_load(net_cigre_mv, bus7, p_kw=76.5, q_kvar=47.41044, name='Load CI7')
pp.create_load(net_cigre_mv, bus9, p_kw=573.75, q_kvar=355.57831, name='Load CI9')
pp.create_load(net_cigre_mv, bus10, p_kw=68.0, q_kvar=42.14262, name='Load CI10')
pp.create_load(net_cigre_mv, bus12, p_kw=5016.0, q_kvar=1648.67947, name='Load CI12')
pp.create_load(net_cigre_mv, bus13, p_kw=34.0, q_kvar=21.07131, name='Load CI13')
pp.create_load(net_cigre_mv, bus14, p_kw=331.5, q_kvar=205.44525, name='Load CI14')
# Optional distributed energy recources
if with_der:
pp.create_sgen(net_cigre_mv, bus3, p_kw=-20, q_kvar=0, sn_kva=20, name='PV 3', type='PV')
pp.create_sgen(net_cigre_mv, bus4, p_kw=-20, q_kvar=0, sn_kva=20, name='PV 4', type='PV')
pp.create_sgen(net_cigre_mv, bus5, p_kw=-30, q_kvar=0, sn_kva=30, name='PV 5', type='PV')
pp.create_sgen(net_cigre_mv, bus6, p_kw=-30, q_kvar=0, sn_kva=30, name='PV 6', type='PV')
pp.create_sgen(net_cigre_mv, bus8, p_kw=-30, q_kvar=0, sn_kva=30, name='PV 8', type='PV')
pp.create_sgen(net_cigre_mv, bus9, p_kw=-30, q_kvar=0, sn_kva=30, name='PV 9', type='PV')
pp.create_sgen(net_cigre_mv, bus10, p_kw=-40, q_kvar=0, sn_kva=40, name='PV 10', type='PV')
pp.create_sgen(net_cigre_mv, bus11, p_kw=-10, q_kvar=0, sn_kva=10, name='PV 11', type='PV')
pp.create_sgen(net_cigre_mv, bus7, p_kw=-1500, q_kvar=0, sn_kva=1500, name='WKA 7',
type='WP')
return net_cigre_mv
#Define Constants DBV = 350 #Demand Bus Voltage in kV, just for now can be changed later GBV = 350 #Generation Bus Voltage in kV, just for now can be changed later Power_factor = 0.8 Theta = np.arccos(Power_factor) P2Q = np.tan(Theta) R_230 = 0.0015 X_230 = 0.00023 C_230 = 100 Max_230 = 25.006 #Create Demand Buses Region1Bus = pp.create_bus(net, vn_kv=500, name="Region 1 Bus") Region2Bus = pp.create_bus(net, vn_kv=500, name="Region 2 Bus") Region3Bus = pp.create_bus(net, vn_kv=DBV, name="Region 3 Bus") NCRBus = pp.create_bus(net, vn_kv=500, name="NCR Bus") Region4ABus = pp.create_bus(net, vn_kv=500, name="Region 4A Bus") CARBus = pp.create_bus(net, vn_kv=DBV, name="CAR Bus") Region4B1Bus = pp.create_bus(net, vn_kv=500, name="Region 4B1 Bus") Region4B2Bus = pp.create_bus(net, vn_kv=230, name="Region 4B2 Bus") Region5Bus = pp.create_bus(net, vn_kv=DBV, name="Region 5 Bus") Region6Bus = pp.create_bus(net, vn_kv=500, name="Region 6 Bus") Region7Bus = pp.create_bus(net, vn_kv=500, name="Region 7 Bus") Region8Bus = pp.create_bus(net, vn_kv=DBV, name="Region 8 Bus") Mindanao1Bus = pp.create_bus(net, vn_kv=DBV, name="Mindanao 1 Bus") Mindanao2Bus = pp.create_bus(net, vn_kv=DBV, name="Mindanao 2 Bus") Mindanao3Bus = pp.create_bus(net, vn_kv=500, name="Mindanao 3 Bus")
def create_cigre_network_lv():
net_cigre_lv = pp.create_empty_network()
# Linedata
# UG1
line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 0.162,
'x_ohm_per_km': 0.0832, 'imax_ka': 1.0,
'type': 'cs'}
pp.create_std_type(net_cigre_lv, line_data, name='UG1', element='line')
# UG2
line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 0.2647,
'x_ohm_per_km': 0.0823, 'imax_ka': 1.0,
'type': 'cs'}
pp.create_std_type(net_cigre_lv, line_data, name='UG2', element='line')
# UG3
line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 0.822,
'x_ohm_per_km': 0.0847, 'imax_ka': 1.0,
'type': 'cs'}
pp.create_std_type(net_cigre_lv, line_data, name='UG3', element='line')
# OH1
line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 0.4917,
'x_ohm_per_km': 0.2847, 'imax_ka': 1.0,
'type': 'ol'}
pp.create_std_type(net_cigre_lv, line_data, name='OH1', element='line')
# OH2
line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 1.3207,
'x_ohm_per_km': 0.321, 'imax_ka': 1.0,
'type': 'ol'}
pp.create_std_type(net_cigre_lv, line_data, name='OH2', element='line')
# OH3
line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 2.0167,
'x_ohm_per_km': 0.3343, 'imax_ka': 1.0,
'type': 'ol'}
pp.create_std_type(net_cigre_lv, line_data, name='OH3', element='line')
# Busses
bus0 = pp.create_bus(net_cigre_lv, name='Bus 0', vn_kv=20.0, type='b', zone='CIGRE_LV')
busR0 = pp.create_bus(net_cigre_lv, name='Bus R0', vn_kv=20.0, type='b', zone='CIGRE_LV')
busR1 = pp.create_bus(net_cigre_lv, name='Bus R1', vn_kv=0.4, type='b', zone='CIGRE_LV')
busR2 = pp.create_bus(net_cigre_lv, name='Bus R2', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR3 = pp.create_bus(net_cigre_lv, name='Bus R3', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR4 = pp.create_bus(net_cigre_lv, name='Bus R4', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR5 = pp.create_bus(net_cigre_lv, name='Bus R5', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR6 = pp.create_bus(net_cigre_lv, name='Bus R6', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR7 = pp.create_bus(net_cigre_lv, name='Bus R7', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR8 = pp.create_bus(net_cigre_lv, name='Bus R8', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR9 = pp.create_bus(net_cigre_lv, name='Bus R9', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR10 = pp.create_bus(net_cigre_lv, name='Bus R10', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR11 = pp.create_bus(net_cigre_lv, name='Bus R11', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR12 = pp.create_bus(net_cigre_lv, name='Bus R12', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR13 = pp.create_bus(net_cigre_lv, name='Bus R13', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR14 = pp.create_bus(net_cigre_lv, name='Bus R14', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR15 = pp.create_bus(net_cigre_lv, name='Bus R15', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR16 = pp.create_bus(net_cigre_lv, name='Bus R16', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR17 = pp.create_bus(net_cigre_lv, name='Bus R17', vn_kv=0.4, type='m', zone='CIGRE_LV')
busR18 = pp.create_bus(net_cigre_lv, name='Bus R18', vn_kv=0.4, type='m', zone='CIGRE_LV')
busI0 = pp.create_bus(net_cigre_lv, name='Bus I0', vn_kv=20.0, type='b', zone='CIGRE_LV')
busI1 = pp.create_bus(net_cigre_lv, name='Bus I1', vn_kv=0.4, type='b', zone='CIGRE_LV')
busI2 = pp.create_bus(net_cigre_lv, name='Bus I2', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC0 = pp.create_bus(net_cigre_lv, name='Bus C0', vn_kv=20.0, type='b', zone='CIGRE_LV')
busC1 = pp.create_bus(net_cigre_lv, name='Bus C1', vn_kv=0.4, type='b', zone='CIGRE_LV')
busC2 = pp.create_bus(net_cigre_lv, name='Bus C2', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC3 = pp.create_bus(net_cigre_lv, name='Bus C3', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC4 = pp.create_bus(net_cigre_lv, name='Bus C4', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC5 = pp.create_bus(net_cigre_lv, name='Bus C5', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC6 = pp.create_bus(net_cigre_lv, name='Bus C6', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC7 = pp.create_bus(net_cigre_lv, name='Bus C7', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC8 = pp.create_bus(net_cigre_lv, name='Bus C8', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC9 = pp.create_bus(net_cigre_lv, name='Bus C9', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC10 = pp.create_bus(net_cigre_lv, name='Bus C10', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC11 = pp.create_bus(net_cigre_lv, name='Bus C11', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC12 = pp.create_bus(net_cigre_lv, name='Bus C12', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC13 = pp.create_bus(net_cigre_lv, name='Bus C13', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC14 = pp.create_bus(net_cigre_lv, name='Bus C14', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC15 = pp.create_bus(net_cigre_lv, name='Bus C15', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC16 = pp.create_bus(net_cigre_lv, name='Bus C16', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC17 = pp.create_bus(net_cigre_lv, name='Bus C17', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC18 = pp.create_bus(net_cigre_lv, name='Bus C18', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC19 = pp.create_bus(net_cigre_lv, name='Bus C19', vn_kv=0.4, type='m', zone='CIGRE_LV')
busC20 = pp.create_bus(net_cigre_lv, name='Bus C20', vn_kv=0.4, type='m', zone='CIGRE_LV')
# Lines
pp.create_line(net_cigre_lv, busR1, busR2, length_km=0.035, std_type='UG1',
name='Line R1-R2')
pp.create_line(net_cigre_lv, busR2, busR3, length_km=0.035, std_type='UG1',
name='Line R2-R3')
pp.create_line(net_cigre_lv, busR3, busR4, length_km=0.035, std_type='UG1',
name='Line R3-R4')
pp.create_line(net_cigre_lv, busR4, busR5, length_km=0.035, std_type='UG1',
name='Line R4-R5')
pp.create_line(net_cigre_lv, busR5, busR6, length_km=0.035, std_type='UG1',
name='Line R5-R6')
pp.create_line(net_cigre_lv, busR6, busR7, length_km=0.035, std_type='UG1',
name='Line R6-R7')
pp.create_line(net_cigre_lv, busR7, busR8, length_km=0.035, std_type='UG1',
name='Line R7-R8')
pp.create_line(net_cigre_lv, busR8, busR9, length_km=0.035, std_type='UG1',
name='Line R8-R9')
pp.create_line(net_cigre_lv, busR9, busR10, length_km=0.035, std_type='UG1',
name='Line R9-R10')
pp.create_line(net_cigre_lv, busR3, busR11, length_km=0.030, std_type='UG3',
name='Line R3-R11')
pp.create_line(net_cigre_lv, busR4, busR12, length_km=0.035, std_type='UG3',
name='Line R4-R12')
pp.create_line(net_cigre_lv, busR12, busR13, length_km=0.035, std_type='UG3',
name='Line R12-R13')
pp.create_line(net_cigre_lv, busR13, busR14, length_km=0.035, std_type='UG3',
name='Line R13-R14')
pp.create_line(net_cigre_lv, busR14, busR15, length_km=0.030, std_type='UG3',
name='Line R14-R15')
pp.create_line(net_cigre_lv, busR6, busR16, length_km=0.030, std_type='UG3',
name='Line R6-R16')
pp.create_line(net_cigre_lv, busR9, busR17, length_km=0.030, std_type='UG3',
name='Line R9-R17')
pp.create_line(net_cigre_lv, busR10, busR18, length_km=0.030, std_type='UG3',
name='Line R10-R18')
pp.create_line(net_cigre_lv, busI1, busI2, length_km=0.2, std_type='UG2',
name='Line I1-I2')
pp.create_line(net_cigre_lv, busC1, busC2, length_km=0.030, std_type='OH1',
name='Line C1-C2')
pp.create_line(net_cigre_lv, busC2, busC3, length_km=0.030, std_type='OH1',
name='Line C2-C3')
pp.create_line(net_cigre_lv, busC3, busC4, length_km=0.030, std_type='OH1',
name='Line C3-C4')
pp.create_line(net_cigre_lv, busC4, busC5, length_km=0.030, std_type='OH1',
name='Line C4-C5')
pp.create_line(net_cigre_lv, busC5, busC6, length_km=0.030, std_type='OH1',
name='Line C5-C6')
pp.create_line(net_cigre_lv, busC6, busC7, length_km=0.030, std_type='OH1',
name='Line C6-C7')
pp.create_line(net_cigre_lv, busC7, busC8, length_km=0.030, std_type='OH1',
name='Line C7-C8')
pp.create_line(net_cigre_lv, busC8, busC9, length_km=0.030, std_type='OH1',
name='Line C8-C9')
pp.create_line(net_cigre_lv, busC3, busC10, length_km=0.030, std_type='OH2',
name='Line C3-C10')
pp.create_line(net_cigre_lv, busC10, busC11, length_km=0.030, std_type='OH2',
name='Line C10-C11')
pp.create_line(net_cigre_lv, busC11, busC12, length_km=0.030, std_type='OH3',
name='Line C11-C12')
pp.create_line(net_cigre_lv, busC11, busC13, length_km=0.030, std_type='OH3',
name='Line C11-C13')
pp.create_line(net_cigre_lv, busC10, busC14, length_km=0.030, std_type='OH3',
name='Line C10-C14')
pp.create_line(net_cigre_lv, busC5, busC15, length_km=0.030, std_type='OH2',
name='Line C5-C15')
pp.create_line(net_cigre_lv, busC15, busC16, length_km=0.030, std_type='OH2',
name='Line C15-C16')
pp.create_line(net_cigre_lv, busC15, busC17, length_km=0.030, std_type='OH3',
name='Line C15-C17')
pp.create_line(net_cigre_lv, busC16, busC18, length_km=0.030, std_type='OH3',
name='Line C16-C18')
pp.create_line(net_cigre_lv, busC8, busC19, length_km=0.030, std_type='OH3',
name='Line C8-C19')
pp.create_line(net_cigre_lv, busC9, busC20, length_km=0.030, std_type='OH3',
name='Line C9-C20')
# Trafos
pp.create_transformer_from_parameters(net_cigre_lv, busR0, busR1, sn_kva=500, vn_hv_kv=20.0,
vn_lv_kv=0.4, vscr_percent=1.0, vsc_percent=4.123106,
pfe_kw=0.0, i0_percent=0.0, shift_degree=30.0,
tp_pos=0.0, name='Trafo R0-R1')
pp.create_transformer_from_parameters(net_cigre_lv, busI0, busI1, sn_kva=150, vn_hv_kv=20.0,
vn_lv_kv=0.4, vscr_percent=1.003125, vsc_percent=4.126896,
pfe_kw=0.0, i0_percent=0.0, shift_degree=30.0,
tp_pos=0.0, name='Trafo I0-I1')
pp.create_transformer_from_parameters(net_cigre_lv, busC0, busC1, sn_kva=300, vn_hv_kv=20.0,
vn_lv_kv=0.4, vscr_percent=0.993750, vsc_percent=4.115529,
pfe_kw=0.0, i0_percent=0.0, shift_degree=30.0,
tp_pos=0.0, name='Trafo C0-C1')
# External grid
pp.create_ext_grid(net_cigre_lv, bus0, vm_pu=1.0, va_degree=0.0, s_sc_max_mva=100.0,
s_sc_min_mva=100.0, rx_max=1.0, rx_min=1.0)
# Loads
pp.create_load(net_cigre_lv, busR1, p_kw=190.0, q_kvar=62.449980, name='Load R1')
pp.create_load(net_cigre_lv, busR11, p_kw=14.25, q_kvar=4.683748, name='Load R11')
pp.create_load(net_cigre_lv, busR15, p_kw=49.4, q_kvar=16.236995, name='Load R15')
pp.create_load(net_cigre_lv, busR16, p_kw=52.25, q_kvar=17.173744, name='Load R16')
pp.create_load(net_cigre_lv, busR17, p_kw=33.25, q_kvar=10.928746, name='Load R17')
pp.create_load(net_cigre_lv, busR18, p_kw=44.65, q_kvar=14.675745, name='Load R18')
pp.create_load(net_cigre_lv, busI2, p_kw=85.0, q_kvar=52.678269, name='Load I2')
pp.create_load(net_cigre_lv, busC1, p_kw=108.0, q_kvar=52.306787, name='Load C1')
pp.create_load(net_cigre_lv, busC12, p_kw=18.0, q_kvar=8.717798, name='Load C12')
pp.create_load(net_cigre_lv, busC13, p_kw=18.0, q_kvar=8.717798, name='Load C13')
pp.create_load(net_cigre_lv, busC14, p_kw=22.5, q_kvar=10.897247, name='Load C14')
pp.create_load(net_cigre_lv, busC17, p_kw=22.5, q_kvar=10.897247, name='Load C17')
pp.create_load(net_cigre_lv, busC18, p_kw=7.2, q_kvar=3.487119, name='Load C18')
pp.create_load(net_cigre_lv, busC19, p_kw=14.4, q_kvar=6.974238, name='Load C19')
pp.create_load(net_cigre_lv, busC20, p_kw=7.2, q_kvar=3.487119, name='Load C20')
# Switches
pp.create_switch(net_cigre_lv, bus0, busR0, et='b', closed=True, type='CB', name='S1')
pp.create_switch(net_cigre_lv, bus0, busI0, et='b', closed=True, type='CB', name='S2')
pp.create_switch(net_cigre_lv, bus0, busC0, et='b', closed=True, type='CB', name='S3')
return net_cigre_lv
def example_multivoltage():
"""
Returns the multivoltage example network from the pandapower tutorials.
OUTPUT:
net - multivoltage example network
EXAMPLE:
>>> import pandapower.networks
>>> net = pandapower.networks.example_multivoltage()
"""
net = pp.create_empty_network()
# --- Busses
# HV
# Double busbar
pp.create_bus(net, name='Double Busbar 1', vn_kv=380, type='b')
pp.create_bus(net, name='Double Busbar 2', vn_kv=380, type='b')
for i in range(10):
pp.create_bus(net, name='Bus DB T%s' % i, vn_kv=380, type='n')
for i in range(1, 5):
pp.create_bus(net, name='Bus DB %s' % i, vn_kv=380, type='n')
# Single busbar
pp.create_bus(net, name='Single Busbar', vn_kv=110, type='b')
for i in range(1, 6):
pp.create_bus(net, name='Bus SB %s' % i, vn_kv=110, type='n')
for i in range(1, 6):
for j in [1, 2]:
pp.create_bus(net,
name='Bus SB T%s.%s' % (i, j),
vn_kv=110,
type='n')
# Remaining
for i in range(1, 5):
pp.create_bus(net, name='Bus HV%s' % i, vn_kv=110, type='n')
# MV
pp.create_bus(net, name='Bus MV0 20kV', vn_kv=20, type='n')
for i in range(8):
pp.create_bus(net, name='Bus MV%s' % i, vn_kv=10, type='n')
# LV
pp.create_bus(net, name='Bus LV0', vn_kv=0.4, type='n')
for i in range(1, 6):
pp.create_bus(net, name='Bus LV1.%s' % i, vn_kv=0.4, type='m')
for i in range(1, 5):
pp.create_bus(net, name='Bus LV2.%s' % i, vn_kv=0.4, type='m')
pp.create_bus(net, name='Bus LV2.2.1', vn_kv=0.4, type='m')
pp.create_bus(net, name='Bus LV2.2.2', vn_kv=0.4, type='m')
# --- Lines
# HV
hv_lines = pd.DataFrame()
hv_lines['line_name'] = ['HV Line%s' % i for i in range(1, 7)]
hv_lines['from_bus'] = [
'Bus SB 2', 'Bus HV1', 'Bus HV2', 'Bus HV1', 'Bus HV3', 'Bus SB 3'
]
hv_lines['to_bus'] = [
'Bus HV1', 'Bus HV2', 'Bus HV4', 'Bus HV4', 'Bus HV4', 'Bus HV3'
]
hv_lines['std_type'] = '184-AL1/30-ST1A 110.0'
hv_lines['length'] = [30, 20, 30, 15, 25, 30]
hv_lines['parallel'] = [1, 1, 1, 1, 1, 2]
for _, hv_line in hv_lines.iterrows():
from_bus = pp.get_element_index(net, "bus", hv_line.from_bus)
to_bus = pp.get_element_index(net, "bus", hv_line.to_bus)
pp.create_line(net,
from_bus,
to_bus,
length_km=hv_line.length,
std_type=hv_line.std_type,
name=hv_line.line_name,
parallel=hv_line.parallel)
# MV
mv_lines = pd.DataFrame()
mv_lines['line_name'] = ['MV Line%s' % i for i in range(1, 9)]
mv_lines['from_bus'] = ['Bus MV%s' % i for i in list(range(7)) + [0]]
mv_lines['to_bus'] = ['Bus MV%s' % i for i in list(range(1, 8)) + [7]]
mv_lines['length'] = 1.5
mv_lines['std_type'] = 'NA2XS2Y 1x185 RM/25 12/20 kV'
for _, mv_line in mv_lines.iterrows():
from_bus = pp.get_element_index(net, "bus", mv_line.from_bus)
to_bus = pp.get_element_index(net, "bus", mv_line.to_bus)
pp.create_line(net,
from_bus,
to_bus,
length_km=mv_line.length,
std_type=mv_line.std_type,
name=mv_line.line_name)
# LV
lv_lines = pd.DataFrame()
lv_line_idx = [
'1.1', '1.2', '1.3', '1.4', '1.6', '2.1', '2.2', '2.3', '2.4', '2.2.1',
'2.2.2'
]
lv_lines['line_name'] = ['LV Line%s' % i for i in lv_line_idx]
lv_line_idx = [
'0', '1.1', '1.2', '1.3', '1.4', '0', '2.1', '2.2', '2.3', '2.2',
'2.2.1'
]
lv_lines['from_bus'] = ['Bus LV%s' % i for i in lv_line_idx]
lv_line_idx = [
'1.1', '1.2', '1.3', '1.4', '1.5', '2.1', '2.2', '2.3', '2.4', '2.2.1',
'2.2.2'
]
lv_lines['to_bus'] = ['Bus LV%s' % i for i in lv_line_idx]
lv_lines['length'] = [0.08] * 5 + [0.12] * 6
lv_lines['std_type'] = ['NAYY 4x120 SE'] * 7 + ['15-AL1/3-ST1A 0.4'] * 4
for _, lv_line in lv_lines.iterrows():
from_bus = pp.get_element_index(net, "bus", lv_line.from_bus)
to_bus = pp.get_element_index(net, "bus", lv_line.to_bus)
pp.create_line(net,
from_bus,
to_bus,
length_km=lv_line.length,
std_type=lv_line.std_type,
name=lv_line.line_name)
# --- Transformer
hv_bus = pp.get_element_index(net, "bus", "Bus DB 2")
lv_bus = pp.get_element_index(net, "bus", "Bus SB 1")
pp.create_transformer_from_parameters(net,
hv_bus,
lv_bus,
sn_mva=300,
vn_hv_kv=380,
vn_lv_kv=110,
vkr_percent=0.06,
vk_percent=8,
pfe_kw=0,
i0_percent=0,
tap_pos=0,
shift_degree=0,
name='EHV-HV-Trafo')
hv_bus = pp.get_element_index(net, "bus", "Bus MV4")
lv_bus = pp.get_element_index(net, "bus", "Bus LV0")
pp.create_transformer_from_parameters(net,
hv_bus,
lv_bus,
sn_mva=0.4,
vn_hv_kv=10,
vn_lv_kv=0.4,
vkr_percent=1.325,
vk_percent=4,
pfe_kw=0.95,
i0_percent=0.2375,
tap_side="hv",
tap_neutral=0,
tap_min=-2,
tap_max=2,
tap_step_percent=2.5,
tap_pos=0,
shift_degree=150,
name='MV-LV-Trafo')
# Trafo3w
hv_bus = pp.get_element_index(net, "bus", "Bus HV2")
mv_bus = pp.get_element_index(net, "bus", "Bus MV0 20kV")
lv_bus = pp.get_element_index(net, "bus", "Bus MV0")
pp.create_transformer3w_from_parameters(net,
hv_bus,
mv_bus,
lv_bus,
vn_hv_kv=110,
vn_mv_kv=20,
vn_lv_kv=10,
sn_hv_mva=40,
sn_mv_mva=15,
sn_lv_mva=25,
vk_hv_percent=10.1,
vk_mv_percent=10.1,
vk_lv_percent=10.1,
vkr_hv_percent=0.266667,
vkr_mv_percent=0.033333,
vkr_lv_percent=0.04,
pfe_kw=0,
i0_percent=0,
shift_mv_degree=30,
shift_lv_degree=30,
tap_side="hv",
tap_neutral=0,
tap_min=-8,
tap_max=8,
tap_step_percent=1.25,
tap_pos=0,
name='HV-MV-MV-Trafo')
# --- Static generators
# HV
pp.create_sgen(net,
pp.get_element_index(net, "bus", 'Bus SB 5'),
p_mw=20,
q_mvar=4,
sn_mva=45,
type='WP',
name='Wind Park')
# MV
mv_sgens = pd.DataFrame()
mv_sgens['sgen_name'] = [
'Biogas plant', 'Further MV Generator', 'Industry Generator', 'PV Park'
]
mv_sgens['bus'] = ['Bus MV6', 'Bus MV0', 'Bus MV0 20kV', 'Bus MV5']
mv_sgens['p'] = [0.5, 0.5, 15, 2]
mv_sgens['q'] = [0, 0.05, 3, 0.1]
mv_sgens['sn'] = [0.75, 1, 20, 5]
mv_sgens['type'] = ['SGEN', 'SGEN', 'SGEN', 'PV']
for _, sgen in mv_sgens.iterrows():
bus_idx = pp.get_element_index(net, "bus", sgen.bus)
pp.create_sgen(net,
bus_idx,
p_mw=sgen.p,
q_mvar=sgen.q,
sn_mva=sgen.sn,
type=sgen.type,
name=sgen.sgen_name)
# LV
lv_sgens = pd.DataFrame()
lv_sgens['sgen_name'] = ['PV'] + ['PV(%s)' % i for i in range(1, 6)]
lv_sgens['bus'] = [
'Bus LV%s' % i for i in ['1.1', '1.3', '2.3', '2.4', '2.2.1', '2.2.2']
]
lv_sgens['p'] = [0.006, 0.005, 0.005, 0.005, 0.005, 0.005]
lv_sgens['q'] = 0
lv_sgens['sn'] = [0.012, 0.01, 0.01, 0.01, 0.01, 0.01]
lv_sgens['type'] = 'PV'
for _, sgen in lv_sgens.iterrows():
bus_idx = pp.get_element_index(net, "bus", sgen.bus)
pp.create_sgen(net,
bus_idx,
p_mw=sgen.p,
q_mvar=sgen.q,
sn_mva=sgen.sn,
type=sgen.type,
name=sgen.sgen_name)
# --- Loads
# HV
hv_loads = pd.DataFrame()
hv_loads['load_name'] = ['MV Net %s' % i for i in range(5)]
hv_loads['bus'] = ['Bus SB 4', 'Bus HV1', 'Bus HV2', 'Bus HV3', 'Bus HV4']
hv_loads['p'] = 38
hv_loads['q'] = 6
for _, load in hv_loads.iterrows():
bus_idx = pp.get_element_index(net, "bus", load.bus)
pp.create_load(net,
bus_idx,
p_mw=load.p,
q_mvar=load.q,
name=load.load_name)
# MV
mv_loads = pd.DataFrame()
mv_loads['load_name'] = ['Further MV-Rings', 'Industry Load'
] + ['LV Net %s' % i for i in [1, 2, 3, 5, 6, 7]]
mv_loads['bus'] = ['Bus MV0', 'Bus MV0 20kV'
] + ['Bus MV%s' % i for i in [1, 2, 3, 5, 6, 7]]
mv_loads['p'] = [6, 18, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4]
mv_loads['q'] = [2, 4, 0.1, 0.06, 0.06, 0.06, 0.06, 0.06]
for _, load in mv_loads.iterrows():
bus_idx = pp.get_element_index(net, "bus", load.bus)
pp.create_load(net,
bus_idx,
p_mw=load.p,
q_mvar=load.q,
name=load.load_name)
# LV
lv_loads = pd.DataFrame()
idx = ['', '(1)', '(2)', '(3)', '(4)', '(5)']
lv_loads['load_name'] = ['Further LV-Feeders Load'] + [
'Residential Load%s' % i for i in idx[0:5]
] + ['Rural Load%s' % i for i in idx[0:6]]
lv_loads['bus'] = [
'Bus LV%s' % i for i in [
'0', '1.1', '1.2', '1.3', '1.4', '1.5', '2.1', '2.2', '2.3', '2.4',
'2.2.1', '2.2.2'
]
]
lv_loads['p'] = [0.1] + [0.01] * 11
lv_loads['q'] = [0.01] + [0.03] * 11
for _, load in lv_loads.iterrows():
bus_idx = pp.get_element_index(net, "bus", load.bus)
pp.create_load(net,
bus_idx,
p_mw=load.p,
q_mvar=load.q,
name=load.load_name)
# --- Other
# Shunt
pp.create_shunt(net,
pp.get_element_index(net, "bus", 'Bus HV1'),
p_mw=0,
q_mvar=-0.96,
name='Shunt')
# ExtGrids
pp.create_ext_grid(net,
pp.get_element_index(net, "bus", 'Double Busbar 1'),
vm_pu=1.03,
va_degree=0,
name='External grid',
s_sc_max_mva=10000,
rx_max=0.1,
rx_min=0.1)
# Gen
pp.create_gen(net,
pp.get_element_index(net, "bus", 'Bus HV4'),
vm_pu=1.03,
p_mw=100,
name='Gas turbine')
# Impedance
pp.create_impedance(net,
pp.get_element_index(net, "bus", 'Bus HV3'),
pp.get_element_index(net, "bus", 'Bus HV1'),
rft_pu=0.074873,
xft_pu=0.198872,
sn_mva=100,
name='Impedance')
# xwards
pp.create_xward(net,
pp.get_element_index(net, "bus", 'Bus HV3'),
ps_mw=23.942,
qs_mvar=-12.24187,
pz_mw=2.814571,
qz_mvar=0,
r_ohm=0,
x_ohm=12.18951,
vm_pu=1.02616,
name='XWard 1')
pp.create_xward(net,
pp.get_element_index(net, "bus", 'Bus HV1'),
ps_mw=3.776,
qs_mvar=-7.769979,
pz_mw=9.174917,
qz_mvar=0,
r_ohm=0,
x_ohm=50.56217,
vm_pu=1.024001,
name='XWard 2')
# --- Switches
# HV
# Bus-bus switches
hv_bus_sw = pd.DataFrame()
hv_bus_sw['bus_name'] = ['DB DS%s' % i for i in range(14)] + \
['DB CB%s' % i for i in range(5)] + \
['SB DS%s.%s' % (i, j) for i in range(1, 6) for j in range(1, 3)] + \
['SB CB%s' % i for i in range(1, 6)]
hv_bus_sw['from_bus'] = ['Double Busbar %s' % i for i in [2, 1, 2, 1, 2, 1, 2, 1, 2, 1]] + \
['Bus DB T%s' % i for i in [2, 4, 6, 8, 0, 3, 5, 7, 9]] + \
['Bus SB T1.1', 'Single Busbar', 'Bus SB T2.1', 'Single Busbar',
'Bus SB T3.1', 'Single Busbar', 'Bus SB T4.1', 'Single Busbar',
'Bus SB T5.1', 'Single Busbar'] + \
['Bus SB T%s.2' % i for i in range(1, 6)]
hv_bus_sw['to_bus'] = ['Bus DB %s' % i for i in
['T0', 'T1', 'T3', 'T3', 'T5', 'T5', 'T7', 'T7', 'T9', 'T9',
'1', '2', '3', '4', 'T1', 'T2', 'T4', 'T6', 'T8']] + \
['Bus SB %s' % i for i in
['1', 'T1.2', '2', 'T2.2', '3', 'T3.2', '4', 'T4.2', '5', 'T5.2']] + \
['Bus SB T%s.1' % i for i in range(1, 6)]
hv_bus_sw['type'] = ['DS'] * 14 + ['CB'] * 5 + ['DS'] * 10 + ['CB'] * 5
hv_bus_sw['et'] = 'b'
hv_bus_sw['closed'] = [
bool(i)
for i in [1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1] +
[1] * 15
]
for _, switch in hv_bus_sw.iterrows():
from_bus = pp.get_element_index(net, "bus", switch.from_bus)
to_bus = pp.get_element_index(net, "bus", switch.to_bus)
pp.create_switch(net,
from_bus,
to_bus,
et=switch.et,
closed=switch.closed,
type=switch.type,
name=switch.bus_name)
# Bus-Line switches
hv_buses = net.bus[(net.bus.vn_kv == 380) | (net.bus.vn_kv == 110)].index
hv_ls = net.line[(net.line.from_bus.isin(hv_buses))
& (net.line.to_bus.isin(hv_buses))]
for _, line in hv_ls.iterrows():
for bus in [line.from_bus, line.to_bus]:
pp.create_switch(net,
bus,
line.name,
et='l',
closed=True,
type='LBS',
name='Switch %s - %s' %
(net.bus.name.at[bus], line['name']))
# MV
# Bus-line switches
mv_buses = net.bus[(net.bus.vn_kv == 10) | (net.bus.vn_kv == 20)].index
mv_ls = net.line[(net.line.from_bus.isin(mv_buses))
& (net.line.to_bus.isin(mv_buses))]
for _, line in mv_ls.iterrows():
for bus in [line.from_bus, line.to_bus]:
pp.create_switch(net,
bus,
line.name,
et='l',
closed=True,
type='LBS',
name='Switch %s - %s' %
(net.bus.name.at[bus], line['name']))
open_switch_id = net.switch[(
net.switch.name == 'Switch Bus MV5 - MV Line5')].index
net.switch.closed.loc[open_switch_id] = False
# LV
# Bus-line switches
lv_buses = net.bus[net.bus.vn_kv == 0.4].index
lv_ls = net.line[(net.line.from_bus.isin(lv_buses))
& (net.line.to_bus.isin(lv_buses))]
for _, line in lv_ls.iterrows():
for bus in [line.from_bus, line.to_bus]:
pp.create_switch(net,
bus,
line.name,
et='l',
closed=True,
type='LBS',
name='Switch %s - %s' %
(net.bus.name.at[bus], line['name']))
# Trafoswitches
# HV
pp.create_switch(net,
pp.get_element_index(net, "bus", 'Bus DB 2'),
pp.get_element_index(net, "trafo", 'EHV-HV-Trafo'),
et='t',
closed=True,
type='LBS',
name='Switch DB2 - EHV-HV-Trafo')
pp.create_switch(net,
pp.get_element_index(net, "bus", 'Bus SB 1'),
pp.get_element_index(net, "trafo", 'EHV-HV-Trafo'),
et='t',
closed=True,
type='LBS',
name='Switch SB1 - EHV-HV-Trafo')
# LV
pp.create_switch(net,
pp.get_element_index(net, "bus", 'Bus MV4'),
pp.get_element_index(net, "trafo", 'MV-LV-Trafo'),
et='t',
closed=True,
type='LBS',
name='Switch MV4 - MV-LV-Trafo')
pp.create_switch(net,
pp.get_element_index(net, "bus", 'Bus LV0'),
pp.get_element_index(net, "trafo", 'MV-LV-Trafo'),
et='t',
closed=True,
type='LBS',
name='Switch LV0 - MV-LV-Trafo')
# --- Powerflow
# run power flow and generate result tables
pp.runpp(net, init='dc', calculate_voltage_angles=True, Numba=False)
return net
def create_cigre_network_hv(length_km_6a_6b=0.1):
net_cigre_hv = pp.create_empty_network()
# Linedata
# Line220kV
line_data = {'c_nf_per_km': 9.08, 'r_ohm_per_km': 0.0653,
'x_ohm_per_km': 0.398, 'imax_ka': 1.14,
'type': 'ol'}
pp.create_std_type(net_cigre_hv, line_data, 'Line220kV', element='line')
# Line380kV
line_data = {'c_nf_per_km': 11.5, 'r_ohm_per_km': 0.0328,
'x_ohm_per_km': 0.312, 'imax_ka': 1.32,
'type': 'ol'}
pp.create_std_type(net_cigre_hv, line_data, 'Line380kV', element='line')
# Busses
bus1 = pp.create_bus(net_cigre_hv, name='Bus 1', vn_kv=220, type='b', zone='CIGRE_HV')
bus2 = pp.create_bus(net_cigre_hv, name='Bus 2', vn_kv=220, type='b', zone='CIGRE_HV')
bus3 = pp.create_bus(net_cigre_hv, name='Bus 3', vn_kv=220, type='b', zone='CIGRE_HV')
bus4 = pp.create_bus(net_cigre_hv, name='Bus 4', vn_kv=220, type='b', zone='CIGRE_HV')
bus5 = pp.create_bus(net_cigre_hv, name='Bus 5', vn_kv=220, type='b', zone='CIGRE_HV')
bus6a = pp.create_bus(net_cigre_hv, name='Bus 6a', vn_kv=220, type='b', zone='CIGRE_HV')
bus6b = pp.create_bus(net_cigre_hv, name='Bus 6b', vn_kv=220, type='b', zone='CIGRE_HV')
bus7 = pp.create_bus(net_cigre_hv, name='Bus 7', vn_kv=380, type='b', zone='CIGRE_HV')
bus8 = pp.create_bus(net_cigre_hv, name='Bus 8', vn_kv=380, type='b', zone='CIGRE_HV')
bus9 = pp.create_bus(net_cigre_hv, name='Bus 9', vn_kv=22, type='b', zone='CIGRE_HV')
bus10 = pp.create_bus(net_cigre_hv, name='Bus 10', vn_kv=22, type='b', zone='CIGRE_HV')
bus11 = pp.create_bus(net_cigre_hv, name='Bus 11', vn_kv=22, type='b', zone='CIGRE_HV')
bus12 = pp.create_bus(net_cigre_hv, name='Bus 12', vn_kv=22, type='b', zone='CIGRE_HV')
# Lines
pp.create_line(net_cigre_hv, bus1, bus2, length_km=100,
std_type='Line220kV', name='Line 1-2')
pp.create_line(net_cigre_hv, bus1, bus6a, length_km=300,
std_type='Line220kV', name='Line 1-6a')
pp.create_line(net_cigre_hv, bus2, bus5, length_km=300,
std_type='Line220kV', name='Line 2-5')
pp.create_line(net_cigre_hv, bus3, bus4, length_km=100,
std_type='Line220kV', name='Line 3-4')
pp.create_line(net_cigre_hv, bus3, bus4, length_km=100,
std_type='Line220kV', name='Line 3-4_2')
pp.create_line(net_cigre_hv, bus4, bus5, length_km=300,
std_type='Line220kV', name='Line 4-5')
pp.create_line(net_cigre_hv, bus4, bus6a, length_km=300,
std_type='Line220kV', name='Line 4-6a')
pp.create_line(net_cigre_hv, bus7, bus8, length_km=600,
std_type='Line380kV', name='Line 7-8')
pp.create_line(net_cigre_hv, bus6a, bus6b, length_km=length_km_6a_6b,
std_type='Line220kV', name='Line 6a-6b')
# Trafos
pp.create_transformer_from_parameters(net_cigre_hv, bus7, bus1, sn_kva=1000000,
vn_hv_kv=380, vn_lv_kv=220, vscr_percent=0.0,
vsc_percent=13.0, pfe_kw=0, i0_percent=0,
shift_degree=0.0, name='Trafo 1-7')
pp.create_transformer_from_parameters(net_cigre_hv, bus8, bus3, sn_kva=1000000,
vn_hv_kv=380, vn_lv_kv=220, vscr_percent=0.0,
vsc_percent=13.0, pfe_kw=0, i0_percent=0,
shift_degree=0.0, name='Trafo 3-8')
pp.create_transformer_from_parameters(net_cigre_hv, bus1, bus9, sn_kva=1000000,
vn_hv_kv=220, vn_lv_kv=22, vscr_percent=0.0,
vsc_percent=13.0, pfe_kw=0, i0_percent=0,
shift_degree=330.0, name='Trafo 9-1')
pp.create_transformer_from_parameters(net_cigre_hv, bus2, bus10, sn_kva=1000000,
vn_hv_kv=220, vn_lv_kv=22, vscr_percent=0.0,
vsc_percent=13.0, pfe_kw=0, i0_percent=0,
shift_degree=330.0, name='Trafo 10-2')
pp.create_transformer_from_parameters(net_cigre_hv, bus3, bus11, sn_kva=1000000,
vn_hv_kv=220, vn_lv_kv=22, vscr_percent=0.0,
vsc_percent=13.0, pfe_kw=0, i0_percent=0,
shift_degree=330.0, name='Trafo 11-3')
pp.create_transformer_from_parameters(net_cigre_hv, bus6b, bus12, sn_kva=500000,
vn_hv_kv=220, vn_lv_kv=22, vscr_percent=0.0,
vsc_percent=13.0, pfe_kw=0, i0_percent=0,
shift_degree=330.0, name='Trafo 12-6b')
# Loads
pp.create_load(net_cigre_hv, bus2, p_kw=285000, q_kvar=200000, name='Load 2')
pp.create_load(net_cigre_hv, bus3, p_kw=325000, q_kvar=244000, name='Load 3')
pp.create_load(net_cigre_hv, bus4, p_kw=326000, q_kvar=244000, name='Load 4')
pp.create_load(net_cigre_hv, bus5, p_kw=103000, q_kvar=62000, name='Load 5')
pp.create_load(net_cigre_hv, bus6a, p_kw=435000, q_kvar=296000, name='Load 6a')
# External grid
pp.create_ext_grid(net_cigre_hv, bus9, vm_pu=1.03, va_degree=0, name='Generator 9')
# Generators
pp.create_gen(net_cigre_hv, bus10, vm_pu=1.03, p_kw=-5e5, name='Generator 10')
pp.create_gen(net_cigre_hv, bus11, vm_pu=1.03, p_kw=-2e5, name='Generator 11')
pp.create_gen(net_cigre_hv, bus12, vm_pu=1.03, p_kw=-3e5, name='Generator 12')
# Shunts
pp.create_shunt(net_cigre_hv, bus4, p_kw=0.0, q_kvar=-160000, name='Shunt 4')
pp.create_shunt(net_cigre_hv, bus5, p_kw=0.0, q_kvar=-80000, name='Shunt 5')
pp.create_shunt(net_cigre_hv, bus6a, p_kw=0.0, q_kvar=-180000, name='Shunt 6a')
return net_cigre_hv
import pandapower as pp #create empty net net = pp.create_empty_network() #create buses bus1 = pp.create_bus(net, vn_kv=20., name="Bus 1") bus2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2") bus3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3") #create bus elements pp.create_ext_grid(net, bus=bus1, vm_pu=1.02, name="Grid Connection") pp.create_load(net, bus=bus3, p_mw=0.100, q_mvar=0.05, name="Load") #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") line = pp.create_line(net, from_bus=bus2, to_bus=bus3, length_km=0.1, std_type="NAYY 4x50 SE", name="Line") pp.runpp(net) #Power Flow print(net.res_bus) net.res_bus net.res_line net.res_trafo print(net.res_bus)
intrC.index = intrC['ID']
intrC_idx = intrC['ID']
intrC.index = intrC['i']
main_idx.drop_duplicates(inplace=True)
coll_idx.drop_duplicates(inplace=True)
intrC_idx.drop_duplicates(inplace=True)
##### CREATE MAIN BRANCH: BUSES & LINES ###############
# creating Secondary Substations
for i in main_idx.index:
if (df.at[i, "Population"] == "0"):
pp.create_bus(net,
vn_kv=20,
type='n',
index=main_idx[i],
geodata=(df.at[main_idx[i], "X"], df.at[main_idx[i],
"Y"]))
else:
pp.create_bus(net,
vn_kv=20,
type='b',
index=main_idx[i],
geodata=(df.at[main_idx[i], "X"], df.at[main_idx[i],
"Y"]))
for i in main_intr.index:
pp.create_line(net,
from_bus=main_intr.at[i, 'ID1'],
to_bus=main_intr.at[i, 'ID2'],
length_km=1,
def test_opf_gen_loading():
""" Testing a simple network with transformer for loading
constraints with OPF using a generator """
# wide open voltage boundaries to make sure they don't interfere with loading constraints
vm_max = 1.5
vm_min = 0.5
max_line_loading = 11
# 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,
vsc_percent=3.75,
tp_max=2,
vn_lv_kv=0.4,
shift_degree=150,
tp_mid=0,
vn_hv_kv=10.0,
vscr_percent=2.8125,
tp_pos=0,
tp_side="hv",
tp_min=-2,
tp_st_percent=2.5,
i0_percent=0.68751,
sn_kva=16.0,
pfe_kw=0.11,
name=None,
in_service=True,
index=None,
max_loading_percent=145)
pp.create_gen(net,
3,
p_kw=-10,
controllable=True,
max_p_kw=-5,
min_p_kw=-15,
max_q_kvar=50,
min_q_kvar=-50)
pp.create_polynomial_cost(net, 0, "gen", array([10, 0]))
pp.create_ext_grid(net, 0)
pp.create_polynomial_cost(net, 0, "ext_grid", array([-.1, 0]))
pp.create_line_from_parameters(net,
1,
2,
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,
max_loading_percent=max_line_loading)
pp.create_line_from_parameters(net,
2,
3,
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,
max_loading_percent=max_line_loading)
# run OPF
pp.runopp(net,
verbose=False,
OPF_VIOLATION=1e-1,
OUT_LIM_LINE=2,
PDIPM_GRADTOL=1e-10,
PDIPM_COMPTOL=1e-10,
PDIPM_COSTTOL=1e-10)
assert net["OPF_converged"]
# assert and check result
logger.debug("test_opf_gen_loading")
logger.debug("res_gen:\n%s" % net.res_gen)
logger.debug("res_line.loading_percent:\n%s" %
net.res_line.loading_percent)
assert max(net.res_line.loading_percent) < max_line_loading
logger.debug("res_trafo.loading_percent:\n%s" %
net.res_trafo.loading_percent)
assert max(net.res_trafo.loading_percent) < 145
assert max(net.res_bus.vm_pu) < vm_max
assert min(net.res_bus.vm_pu) > vm_min
def test_pandapower_case():
#more complicated examples like
#net = pandapower.networks.example_simple()
#can be used once the import of e.g. switches is perfected
#create empty net
net = pp.create_empty_network()
#create buses
b1 = pp.create_bus(net, vn_kv=20., name="Bus 1")
b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2")
b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3")
#create bus elements
pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection")
pp.create_load(net, bus=b3, p_kw=100, q_kvar=50, name="Load")
#create branch elements
tid = pp.create_transformer(net, hv_bus=b1, lv_bus=b2, std_type="0.4 MVA 20/0.4 kV",
name="Trafo")
pp.create_line(net, from_bus=b2, to_bus=b3, length_km=0.1, name="Line",
std_type="NAYY 4x50 SE")
#because of phase angles, need to init with DC
pp.runpp(net,calculate_voltage_angles=True,init="dc")
n = pypsa.Network()
n.import_from_pandapower_net(net)
#seed PF with LPF solution because of phase angle jumps
n.lpf()
n.pf(use_seed=True)
#use same index for everything
net.res_bus.index = net.bus.name.values
net.res_line.index = net.line.name.values
#compare bus angles
np.testing.assert_array_almost_equal(n.buses_t.v_ang.loc["now"]*180/np.pi,net.res_bus.va_degree)
#compare bus voltage magnitudes
np.testing.assert_array_almost_equal(n.buses_t.v_mag_pu.loc["now"],net.res_bus.vm_pu)
#compare bus active power (NB: pandapower uses load signs)
np.testing.assert_array_almost_equal(n.buses_t.p.loc["now"],-net.res_bus.p_kw/1e3)
#compare bus active power (NB: pandapower uses load signs)
np.testing.assert_array_almost_equal(n.buses_t.q.loc["now"],-net.res_bus.q_kvar/1e3)
#compare branch flows
np.testing.assert_array_almost_equal(n.lines_t.p0.loc["now"],net.res_line.p_from_kw/1e3)
np.testing.assert_array_almost_equal(n.lines_t.p1.loc["now"],net.res_line.p_to_kw/1e3)
np.testing.assert_array_almost_equal(n.lines_t.q0.loc["now"],net.res_line.q_from_kvar/1e3)
np.testing.assert_array_almost_equal(n.lines_t.q1.loc["now"],net.res_line.q_to_kvar/1e3)
np.testing.assert_array_almost_equal(n.transformers_t.p0.loc["now"],net.res_trafo.p_hv_kw/1e3)
np.testing.assert_array_almost_equal(n.transformers_t.p1.loc["now"],net.res_trafo.p_lv_kw/1e3)
np.testing.assert_array_almost_equal(n.transformers_t.q0.loc["now"],net.res_trafo.q_hv_kvar/1e3)
np.testing.assert_array_almost_equal(n.transformers_t.q1.loc["now"],net.res_trafo.q_lv_kvar/1e3)
