def build_case_grid(self):
grid = pp.create_empty_network()
# Buses
# Substation bus 1
bus0 = pp.create_bus(grid,
vn_kv=self.base_unit_v / 1000,
name="bus-0-0")
bus1 = pp.create_bus(grid,
vn_kv=self.base_unit_v / 1000,
name="bus-1-1")
bus2 = pp.create_bus(grid,
vn_kv=self.base_unit_v / 1000,
name="bus-2-2")
bus3 = pp.create_bus(grid,
vn_kv=self.base_unit_v / 1000,
name="bus-3-3")
bus4 = pp.create_bus(grid,
vn_kv=self.base_unit_v / 1000,
name="bus-4-4")
bus5 = pp.create_bus(grid,
vn_kv=self.base_unit_v / 1000,
name="bus-5-5")
# Substation bus 2
pp.create_bus(grid, vn_kv=self.base_unit_v / 1000, name="bus-6-0")
pp.create_bus(grid, vn_kv=self.base_unit_v / 1000, name="bus-7-1")
pp.create_bus(grid, vn_kv=self.base_unit_v / 1000, name="bus-8-2")
pp.create_bus(grid, vn_kv=self.base_unit_v / 1000, name="bus-9-3")
pp.create_bus(grid, vn_kv=self.base_unit_v / 1000, name="bus-10-4")
pp.create_bus(grid, vn_kv=self.base_unit_v / 1000, name="bus-11-5")
# Lines
pp.create_line_from_parameters(
grid,
bus0,
bus1,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 4.0 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-0",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus0,
bus3,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 4.706 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-1",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus0,
bus4,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 3.102 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-2",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus1,
bus2,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 3.846 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-3",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus1,
bus3,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 8.001 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-4",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus1,
bus4,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 3.0 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-5",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus1,
bus5,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 1.454 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-6",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus2,
bus4,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 3.175 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-7",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus2,
bus5,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 9.6157 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-8",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus3,
bus4,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 2.0 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-9",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus4,
bus5,
length_km=1.0,
r_ohm_per_km=1e-3 * self.base_unit_z, # Dummy
x_ohm_per_km=1.0 / 3.0 * self.base_unit_z,
c_nf_per_km=0.0, # Dummy
max_i_ka=self.convert_per_unit_to_ka(2.0),
name="line-10",
type="ol",
max_loading_percent=100.0,
)
# Loads
pp.create_load(
grid,
bus3,
p_mw=self.convert_per_unit_to_mw(0.9),
name="load-0",
controllable=False,
)
pp.create_load(
grid,
bus4,
p_mw=self.convert_per_unit_to_mw(1.0),
name="load-1",
controllable=False,
)
pp.create_load(
grid,
bus5,
p_mw=self.convert_per_unit_to_mw(0.9),
name="load-2",
controllable=False,
)
# Generators
pp.create_gen(
grid,
bus0,
p_mw=self.convert_per_unit_to_mw(1.0),
min_p_mw=self.convert_per_unit_to_mw(0.5),
max_p_mw=self.convert_per_unit_to_mw(1.5),
slack=True,
name="gen-0",
)
pp.create_gen(
grid,
bus1,
p_mw=self.convert_per_unit_to_mw(0.9),
min_p_mw=self.convert_per_unit_to_mw(0.5),
max_p_mw=self.convert_per_unit_to_mw(2.0),
name="gen-1",
)
pp.create_gen(
grid,
bus2,
p_mw=self.convert_per_unit_to_mw(0.9),
min_p_mw=self.convert_per_unit_to_mw(0.3),
max_p_mw=self.convert_per_unit_to_mw(1.0),
name="gen-2",
)
return grid
def test_3bus_with_bad_data():
net = pp.create_empty_network()
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_ext_grid(net, 0)
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
# 1. Create false voltage measurement for testing bad data detection (-> should be removed)
pp.create_measurement(net, "v", "bus", 1.3, 0.01, bus=1) # V at bus 2
# 2. Do chi2-test
bad_data_detected = chi2_analysis(net, init='flat')
# 3. Perform rn_max_test
success_rn_max = remove_bad_data(net, init='flat')
v_est_rn_max = net.res_bus_est.vm_pu.values
delta_est_rn_max = net.res_bus_est.va_degree.values
target_v = np.array([1.0627, 1.0589, 1.0317])
diff_v = target_v - v_est_rn_max
target_delta = np.array([0., 0.8677, 3.1381])
diff_delta = target_delta - delta_est_rn_max
assert bad_data_detected
assert success_rn_max
assert (np.nanmax(abs(diff_v)) < 1e-4)
assert (np.nanmax(abs(diff_delta)) < 1e-4)
def test_3bus_with_transformer():
np.random.seed(12)
# 1. Create network
net = pp.create_empty_network()
pp.create_bus(net, name="bus1", vn_kv=10.)
pp.create_bus(net, name="bus2", vn_kv=10.)
pp.create_bus(net, name="bus3", vn_kv=10.)
pp.create_bus(net, name="bus4", vn_kv=110.)
pp.create_ext_grid(net, bus=3, vm_pu=1.01)
pp.create_line_from_parameters(net,
0,
1,
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,
0,
2,
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,
1,
2,
1,
r_ohm_per_km=.03,
x_ohm_per_km=.08,
c_nf_per_km=0.,
max_i_ka=1)
pp.create_transformer(net,
3,
0,
std_type="25 MVA 110/10 kV v1.4.3 and older")
pp.create_load(net, 1, 450, 300)
pp.create_load(net, 2, 350, 200)
pp.runpp(net, calculate_voltage_angles=True)
pp.create_measurement(net,
"v",
"bus",
r2(net.res_bus.vm_pu.iloc[0], .004),
.004,
bus=0)
pp.create_measurement(net,
"v",
"bus",
r2(net.res_bus.vm_pu.iloc[1], .004),
.004,
bus=1)
pp.create_measurement(net,
"v",
"bus",
r2(net.res_bus.vm_pu.iloc[3], .004),
.004,
bus=3)
pp.create_measurement(net,
"p",
"bus",
-r2(net.res_bus.p_kw.iloc[1], 10),
10,
bus=1)
pp.create_measurement(net,
"q",
"bus",
-r2(net.res_bus.q_kvar.iloc[1], 10),
10,
bus=1)
pp.create_measurement(net,
"p",
"bus",
-r2(net.res_bus.p_kw.iloc[2], 10),
10,
bus=2)
pp.create_measurement(net,
"q",
"bus",
-r2(net.res_bus.q_kvar.iloc[2], 10),
10,
bus=2)
pp.create_measurement(net, "p", "bus", 0., 1.0, bus=0)
pp.create_measurement(net, "q", "bus", 0., 1.0, bus=0)
pp.create_measurement(net, "p", "line",
r2(net.res_line.p_from_kw.iloc[0], 8), 8, 0, 0)
pp.create_measurement(net, "p", "line",
r2(net.res_line.p_from_kw.iloc[1], 8), 8, 0, 1)
pp.create_measurement(net,
"p",
"transformer",
r2(net.res_trafo.p_hv_kw.iloc[0], 10),
10,
bus=3,
element=0) # transformer meas.
pp.create_measurement(net,
"q",
"transformer",
r2(net.res_trafo.q_hv_kvar.iloc[0], 10),
10,
bus=3,
element=0) # at hv side
# 2. Do state estimation
success = estimate(net,
init='slack',
tolerance=5e-5,
maximum_iterations=10,
calculate_voltage_angles=True)
v_result = net.res_bus_est.vm_pu.values
delta_result = net.res_bus_est.va_degree.values
diff_v = net.res_bus.vm_pu.values - v_result
diff_delta = net.res_bus.va_degree.values - delta_result
assert success
assert (np.nanmax(abs(diff_v)) < 6e-4)
assert (np.nanmax(abs(diff_delta)) < 1.4e-4)
# Backwards check. Use state estimation results for power flow and check for equality
net.load.drop(net.load.index, inplace=True)
net.ext_grid.vm_pu = net.res_bus_est.vm_pu.iloc[net.ext_grid.bus.iloc[0]]
pp.create_load(net, 0, net.res_bus_est.p_kw.iloc[0],
net.res_bus_est.q_kvar.iloc[0])
pp.create_load(net, 1, net.res_bus_est.p_kw.iloc[1],
net.res_bus_est.q_kvar.iloc[1])
pp.create_load(net, 2, net.res_bus_est.p_kw.iloc[2],
net.res_bus_est.q_kvar.iloc[2])
_compare_pf_and_se_results(net)
def add_test_oos_bus_with_is_element(net):
b1, b2, ln = add_grid_connection(net, zone="test_oos_bus_with_is_element")
pl = 1200
ql = 1100
ps = -500
u_set = 1.0
pz = 1200
qz = 1100
qs = 200
vm_pu = 1.06
r_ohm = 50
x_ohm = 70
# OOS buses
b3 = pp.create_bus(net,
zone="test_oos_bus_with_is_element",
vn_kv=0.4,
in_service=False)
b4 = pp.create_bus(net,
zone="test_oos_bus_with_is_element",
vn_kv=0.4,
in_service=False)
b5 = pp.create_bus(net,
zone="test_oos_bus_with_is_element",
vn_kv=0.4,
in_service=False)
pp.create_line_from_parameters(net,
b2,
b3,
12.2,
r_ohm_per_km=0.08,
x_ohm_per_km=0.12,
c_nf_per_km=300,
max_i_ka=.2,
df=.8)
pp.create_line_from_parameters(net,
b2,
b4,
12.2,
r_ohm_per_km=0.08,
x_ohm_per_km=0.12,
c_nf_per_km=300,
max_i_ka=.2,
df=.8)
pp.create_line_from_parameters(net,
b2,
b5,
12.2,
r_ohm_per_km=0.08,
x_ohm_per_km=0.12,
c_nf_per_km=300,
max_i_ka=.2,
df=.8)
# in service elements
pp.create_load(net, b3, p_kw=pl, q_kvar=ql)
pp.create_gen(net, b4, p_kw=ps, vm_pu=u_set)
pp.create_sgen(net, b5, p_kw=ps, q_kvar=ql)
pp.create_ward(net, b3, pz_kw=pz, qz_kvar=qz, ps_kw=ps, qs_kvar=qs)
pp.create_xward(net,
b4,
pz_kw=0.5 * pz,
qz_kvar=0.5 * qz,
ps_kw=0.5 * ps,
qs_kvar=0.5 * qs,
vm_pu=vm_pu,
x_ohm=x_ohm,
r_ohm=r_ohm)
pp.create_shunt(net, b5, q_kvar=-800, p_kw=0)
net.last_added_case = "test_oos_bus_with_is_element"
return net
def iec_60909_4_small(n_t3=1, num_earth=1, with_gen=False):
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=380.)
b2 = pp.create_bus(net, vn_kv=110.)
b3 = pp.create_bus(net, vn_kv=110.)
b5 = pp.create_bus(net, vn_kv=110.)
b8 = pp.create_bus(net, vn_kv=30.)
HG2 = pp.create_bus(net, vn_kv=10)
pp.create_ext_grid(
net,
b1,
s_sc_max_mva=38 * 380 * np.sqrt(3),
rx_max=0.1,
x0x_max=3,
r0x0_max=0.15,
s_sc_min_mva=38 * 380 * np.sqrt(3) / 10,
rx_min=0.1,
x0x_min=3,
r0x0_min=0.15,
)
pp.create_ext_grid(net,
b5,
s_sc_max_mva=16 * 110 * np.sqrt(3),
rx_max=0.1,
x0x_max=3.3,
r0x0_max=0.2,
s_sc_min_mva=16 * 110 * np.sqrt(3) / 10,
rx_min=0.1,
x0x_min=3.3,
r0x0_min=0.2)
if num_earth == 1:
vector_group = ("YYNd", "YNYd")
else:
vector_group = ("YNYNd", "YNYNd")
if n_t3 == 2:
pp.create_transformer3w_from_parameters(net,
hv_bus=b1,
mv_bus=b2,
lv_bus=b8,
vn_hv_kv=400,
vn_mv_kv=120,
vn_lv_kv=30,
sn_hv_mva=350,
sn_mv_mva=350,
sn_lv_mva=50,
pfe_kw=0,
i0_percent=0,
vk_hv_percent=21,
vkr_hv_percent=.26,
vk_mv_percent=7,
vkr_mv_percent=.16,
vk_lv_percent=10.,
vkr_lv_percent=.16,
vk0_hv_percent=44.1,
vkr0_hv_percent=0.26,
vk0_mv_percent=6.2996,
vkr0_mv_percent=0.03714,
vk0_lv_percent=6.2996,
vkr0_lv_percent=0.03714,
vector_group=vector_group[0])
pp.create_transformer3w_from_parameters(net,
hv_bus=b1,
mv_bus=b2,
lv_bus=b8,
vn_hv_kv=400,
vn_mv_kv=120,
vn_lv_kv=30,
sn_hv_mva=350,
sn_mv_mva=350,
sn_lv_mva=50,
pfe_kw=0,
i0_percent=0,
vk_hv_percent=21,
vkr_hv_percent=.26,
vk_mv_percent=7,
vkr_mv_percent=.16,
vk_lv_percent=10.,
vkr_lv_percent=.16,
vk0_hv_percent=44.1,
vkr0_hv_percent=0.26,
vk0_mv_percent=6.2996,
vkr0_mv_percent=0.03714,
vk0_lv_percent=6.2996,
vkr0_lv_percent=0.03714,
vector_group=vector_group[1])
pp.create_line_from_parameters(
net,
b2,
b3,
name="L1",
c_nf_per_km=0,
max_i_ka=0, # FIXME: Optional for SC
length_km=20,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39,
r0_ohm_per_km=0.32,
x0_ohm_per_km=1.26,
c0_nf_per_km=0,
g0_us_per_km=0,
endtemp_degree=80)
pp.create_line_from_parameters(net,
b2,
b5,
name="L3a",
c_nf_per_km=0,
max_i_ka=0,
length_km=5,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39,
r0_ohm_per_km=0.52,
x0_ohm_per_km=1.86,
c0_nf_per_km=0,
g0_us_per_km=0,
endtemp_degree=80)
pp.create_line_from_parameters(net,
b2,
b5,
name="L3b",
c_nf_per_km=0,
max_i_ka=0,
length_km=5,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39,
r0_ohm_per_km=0.52,
x0_ohm_per_km=1.86,
c0_nf_per_km=0,
g0_us_per_km=0,
endtemp_degree=80)
pp.create_line_from_parameters(net,
b5,
b3,
name="L4",
c_nf_per_km=0,
max_i_ka=0,
length_km=10,
r_ohm_per_km=0.096,
x_ohm_per_km=0.388,
r0_ohm_per_km=0.22,
x0_ohm_per_km=1.1,
c0_nf_per_km=0,
g0_us_per_km=0,
endtemp_degree=80)
if with_gen:
t1 = pp.create_transformer_from_parameters(net,
b3,
HG2,
sn_mva=100,
pfe_kw=0,
i0_percent=0,
vn_hv_kv=120.,
vn_lv_kv=10.5,
vk_percent=12,
vkr_percent=0.5,
vk0_percent=12,
vkr0_percent=0.5,
mag0_percent=100,
mag0_rx=0,
si0_hv_partial=0.5,
shift_degree=5,
vector_group="YNd")
pp.create_gen(net,
HG2,
p_mw=0.9 * 100,
vn_kv=10.5,
xdss_pu=0.16,
rdss_ohm=0.005,
cos_phi=0.9,
sn_mva=100,
pg_percent=7.5,
slack=True,
power_station_trafo=t1)
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)
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,
imax_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,
imax_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, 3, p_kw=-200., vm_pu=1.0)
pp.create_sgen(net, 2, p_kw=-50, sn_kva=100)
return net
def test_replace_zero_branches_with_switches():
net = pp.create_empty_network()
bus0 = pp.create_bus(net, vn_kv=0.4)
bus1 = pp.create_bus(net, vn_kv=0.4)
bus2 = pp.create_bus(net, vn_kv=0.4)
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=0.4)
bus6 = pp.create_bus(net, vn_kv=0.4)
pp.create_ext_grid(net, bus0, vm_pu=0.4)
line0 = pp.create_line(net, bus0, bus1, length_km=0, std_type="NAYY 4x50 SE")
line1 = pp.create_line_from_parameters(net, bus2, bus3, length_km=1, r_ohm_per_km=0,
x_ohm_per_km=0.1, c_nf_per_km=0, max_i_ka=1)
line2 = pp.create_line_from_parameters(net, bus3, bus4, length_km=1, r_ohm_per_km=0,
x_ohm_per_km=0, c_nf_per_km=0, max_i_ka=1)
impedance0 = pp.create_impedance(net, bus1, bus2, 0.01, 0.01, sn_kva=1e5)
impedance1 = pp.create_impedance(net, bus4, bus5, 0, 0, sn_kva=1e5)
impedance2 = pp.create_impedance(net, bus5, bus6, 0, 0, rtf_pu=0.1, sn_kva=1e5)
# test for line with zero length
tb.replace_zero_branches_with_switches(net, elements=('line',), zero_length=True,
zero_impedance=False, in_service_only=True)
assert 'REPLACEMENT_line_0' in net.switch.name.values
assert ~net.line.in_service.at[0]
# test for in_service_only
tb.replace_zero_branches_with_switches(net, elements=('line',), zero_length=True,
zero_impedance=False, in_service_only=True)
assert len(net.switch.loc[net.switch.name == 'REPLACEMENT_line_0']) == 1
tb.replace_zero_branches_with_switches(net, elements=('line',), zero_length=True,
zero_impedance=False, in_service_only=False)
assert len(net.switch.loc[net.switch.name == 'REPLACEMENT_line_0']) == 2
assert ~net.switch.closed.at[1]
# test for line with zero impedance
tb.replace_zero_branches_with_switches(net, elements=('line',), zero_length=False,
zero_impedance=True, in_service_only=True)
assert 'REPLACEMENT_line_1' not in net.switch.name.values
assert 'REPLACEMENT_line_2' in net.switch.name.values
# test for impedance
tb.replace_zero_branches_with_switches(net, elements=('impedance',), zero_length=False,
zero_impedance=True, in_service_only=True)
assert 'REPLACEMENT_impedance_0' not in net.switch.name.values
assert 'REPLACEMENT_impedance_1' in net.switch.name.values
assert 'REPLACEMENT_impedance_2' not in net.switch.name.values
# now run everything altogether
net.switch.drop(net.switch.index, inplace=True)
net.line.loc[:, 'in_service'] = True
net.impedance.loc[:, 'in_service'] = True
tb.replace_zero_branches_with_switches(net, elements=('impedance', 'line'), zero_length=True,
zero_impedance=True, in_service_only=True)
assert 'REPLACEMENT_impedance_1' in net.switch.name.values
assert 'REPLACEMENT_line_0' in net.switch.name.values
assert 'REPLACEMENT_line_2' in net.switch.name.values
assert ~net.line.in_service.at[0]
assert net.line.in_service.at[1]
assert ~net.line.in_service.at[2]
assert 'REPLACEMENT_impedance_0' not in net.switch.name.values
assert 'REPLACEMENT_impedance_2' not in net.switch.name.values
assert 'REPLACEMENT_line_1' not in net.switch.name.values
assert net.impedance.in_service.at[0]
assert ~net.impedance.in_service.at[1]
assert net.impedance.in_service.at[2]
def iec_60909_4():
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=380.)
b2 = pp.create_bus(net, vn_kv=110.)
b3 = pp.create_bus(net, vn_kv=110.)
b4 = pp.create_bus(net, vn_kv=110.)
b5 = pp.create_bus(net, vn_kv=110.)
b6 = pp.create_bus(net, vn_kv=10.)
b7 = pp.create_bus(net, vn_kv=10.)
b8 = pp.create_bus(net, vn_kv=30.)
H = pp.create_bus(net, vn_kv=30.)
HG1 = pp.create_bus(net, vn_kv=21.)
HG2 = pp.create_bus(net, vn_kv=10.5) # 10.5kV?
T_T5 = pp.create_bus(net, vn_kv=10.5)
T_T6 = pp.create_bus(net, vn_kv=10.5)
pp.create_ext_grid(net, b1, s_sc_max_mva=38 * 380 * np.sqrt(3), rx_max=0.1)
pp.create_ext_grid(net, b5, s_sc_max_mva=16 * 110 * np.sqrt(3), rx_max=0.1)
pp.create_gen(net,
HG2,
p_mw=0.9 * 100,
vn_kv=10.5,
xdss_pu=0.16,
rdss_pu=0.005,
cos_phi=0.9,
sn_mva=100)
pp.create_gen(net,
HG1,
p_mw=0.85 * 150,
vn_kv=21,
xdss_pu=0.14,
rdss_pu=0.002,
cos_phi=0.85,
sn_mva=150)
pp.create_gen(net,
b6,
p_mw=0.8 * 10,
vn_kv=10.5,
xdss_pu=0.1,
rdss_pu=0.018,
cos_phi=0.8,
sn_mva=10)
pp.create_transformer_from_parameters(
net,
b4,
HG1,
sn_mva=150,
pfe_kw=0,
i0_percent=0, # FIXME: Optional for SC
vn_hv_kv=115.,
vn_lv_kv=21,
vk_percent=16,
vkr_percent=0.5)
pp.create_transformer_from_parameters(net,
b3,
HG2,
sn_mva=100,
pfe_kw=0,
i0_percent=0,
vn_hv_kv=120.,
vn_lv_kv=10.5,
vk_percent=12,
vkr_percent=0.5)
pp.create_transformer3w_from_parameters(
net,
hv_bus=b1,
mv_bus=b2,
lv_bus=H,
vn_hv_kv=400,
vn_mv_kv=120,
vn_lv_kv=30,
sn_hv_mva=350,
sn_mv_mva=350,
sn_lv_mva=50,
pfe_kw=0,
i0_percent=0, # FIXME: Optional for SC
vk_hv_percent=21,
vkr_hv_percent=.26,
vk_mv_percent=10,
vkr_mv_percent=.16,
vk_lv_percent=7.,
vkr_lv_percent=.16)
pp.create_transformer3w_from_parameters(net,
hv_bus=b1,
mv_bus=b2,
lv_bus=b8,
vn_hv_kv=400,
vn_mv_kv=120,
vn_lv_kv=30,
sn_hv_mva=350,
sn_mv_mva=350,
sn_lv_mva=50,
pfe_kw=0,
i0_percent=0,
vk_hv_percent=21,
vkr_hv_percent=.26,
vk_mv_percent=10,
vkr_mv_percent=.16,
vk_lv_percent=7.,
vkr_lv_percent=.16)
pp.create_transformer3w_from_parameters(
net,
hv_bus=b5,
mv_bus=b6,
lv_bus=T_T5,
vn_hv_kv=115.,
vn_mv_kv=10.5,
vn_lv_kv=10.5,
sn_hv_mva=31.5,
sn_mv_mva=31.5,
sn_lv_mva=31.5,
pfe_kw=0,
i0_percent=0, # FIXME: Optional for SC
vk_hv_percent=12,
vkr_hv_percent=.5,
vk_mv_percent=12,
vkr_mv_percent=.5,
vk_lv_percent=12,
vkr_lv_percent=.5)
pp.create_transformer3w_from_parameters(
net,
hv_bus=b5,
mv_bus=b6,
lv_bus=T_T6,
vn_hv_kv=115.,
vn_mv_kv=10.5,
vn_lv_kv=10.5,
sn_hv_mva=31.5,
sn_mv_mva=31.5,
sn_lv_mva=31.5,
pfe_kw=0,
i0_percent=0, # FIXME: Optional for SC
vk_hv_percent=12,
vkr_hv_percent=.5,
vk_mv_percent=12,
vkr_mv_percent=.5,
vk_lv_percent=12,
vkr_lv_percent=.5)
# pp.create_transformer_from_parameters(net, b5, b6, sn_mva=31.5,
# pfe_kw=0, i0_percent=0, # FIXME: Optional for SC
# vn_hv_kv=115., vn_lv_kv=10.5, vk_percent=12, vkr_percent=0.5)
# pp.create_transformer_from_parameters(net, b5, b6, sn_mva=31.5,
# pfe_kw=0, i0_percent=0, # FIXME: Optional for SC
# vn_hv_kv=115., vn_lv_kv=10.5, vk_percent=12, vkr_percent=0.5)
# First try without motor in powerfactory
# pp.create_motor(net, b7, p_mw=5.0, sn_mva=5.0 / 0.88, k=5, rx=0.1) # FIXME: R/X
# pp.create_motor(net, b7, p_mw=2.0, sn_mva=2.0 / 0.89, k=5.2, rx=0.1)
# pp.create_motor(net, b7, p_mw=2.0, sn_mva=2.0 / 0.89, k=5.2, rx=0.1)
pp.create_line_from_parameters(
net,
b2,
b3,
name="L1",
c_nf_per_km=0,
max_i_ka=0, # FIXME: Optional for SC
length_km=20,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39)
pp.create_line_from_parameters(net,
b3,
b4,
name="L2",
c_nf_per_km=0,
max_i_ka=0,
length_km=10,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39)
pp.create_line_from_parameters(net,
b2,
b5,
name="L3a",
c_nf_per_km=0,
max_i_ka=0,
length_km=5,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39)
pp.create_line_from_parameters(net,
b2,
b5,
name="L3b",
c_nf_per_km=0,
max_i_ka=0,
length_km=5,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39)
pp.create_line_from_parameters(net,
b5,
b3,
name="L4",
c_nf_per_km=0,
max_i_ka=0,
length_km=10,
r_ohm_per_km=0.096,
x_ohm_per_km=0.388)
pp.create_line_from_parameters(net,
b5,
b4,
name="L5",
c_nf_per_km=0,
max_i_ka=0,
length_km=15,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39)
pp.create_line_from_parameters(net,
b6,
b7,
name="L6",
c_nf_per_km=0,
max_i_ka=0,
length_km=1,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39)
return net
def iec_60909_4_small():
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=380.)
b2 = pp.create_bus(net, vn_kv=110.)
b3 = pp.create_bus(net, vn_kv=110.)
b5 = pp.create_bus(net, vn_kv=110.)
b8 = pp.create_bus(net, vn_kv=30.)
H = pp.create_bus(net, vn_kv=30.)
HG1 = pp.create_bus(net, vn_kv=21.)
HG2 = pp.create_bus(net, vn_kv=10) # 10.5kV?
T_T5 = pp.create_bus(net, vn_kv=10.5)
T_T6 = pp.create_bus(net, vn_kv=10.5)
pp.create_ext_grid(net, b1, s_sc_max_mva=38 * 380 * np.sqrt(3), rx_max=0.1)
pp.create_ext_grid(net, b5, s_sc_max_mva=16 * 110 * np.sqrt(3), rx_max=0.1)
pp.create_gen(net,
HG2,
p_mw=0.9 * 100,
vn_kv=10.5,
xdss_pu=0.16,
rdss_pu=0.005,
cos_phi=0.9,
sn_mva=100)
pp.create_transformer_from_parameters(net,
b3,
HG2,
sn_mva=100,
pfe_kw=0,
i0_percent=0,
vn_hv_kv=120.,
vn_lv_kv=10.5,
vk_percent=12,
vkr_percent=0.5)
pp.create_transformer3w_from_parameters(
net,
hv_bus=b1,
mv_bus=b2,
lv_bus=H,
vn_hv_kv=400,
vn_mv_kv=120,
vn_lv_kv=30,
sn_hv_mva=350,
sn_mv_mva=350,
sn_lv_mva=50,
pfe_kw=0,
i0_percent=0, # FIXME: Optional for SC
vk_hv_percent=21,
vkr_hv_percent=.26,
vk_mv_percent=7,
vkr_mv_percent=.16,
vk_lv_percent=10.,
vkr_lv_percent=.16)
pp.create_transformer3w_from_parameters(net,
hv_bus=b1,
mv_bus=b2,
lv_bus=b8,
vn_hv_kv=400,
vn_mv_kv=120,
vn_lv_kv=30,
sn_hv_mva=350,
sn_mv_mva=350,
sn_lv_mva=50,
pfe_kw=0,
i0_percent=0,
vk_hv_percent=21,
vkr_hv_percent=.26,
vk_mv_percent=7,
vkr_mv_percent=.16,
vk_lv_percent=10.,
vkr_lv_percent=.16)
pp.create_line_from_parameters(
net,
b2,
b3,
name="L1",
c_nf_per_km=0,
max_i_ka=0, # FIXME: Optional for SC
length_km=20,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39,
)
pp.create_line_from_parameters(net,
b2,
b5,
name="L3a",
c_nf_per_km=0,
max_i_ka=0,
length_km=5,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39)
pp.create_line_from_parameters(net,
b2,
b5,
name="L3b",
c_nf_per_km=0,
max_i_ka=0,
length_km=5,
r_ohm_per_km=0.12,
x_ohm_per_km=0.39)
pp.create_line_from_parameters(net,
b5,
b3,
name="L4",
c_nf_per_km=0,
max_i_ka=0,
length_km=10,
r_ohm_per_km=0.096,
x_ohm_per_km=0.388)
return net
def test_opf_sgen_loading():
""" Testing a simple network with transformer for loading
constraints with OPF using a generator """
# boundaries
vm_max = 1.5
vm_min = 0.5
max_trafo_loading = 800
max_line_loading = 13
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_transformer_from_parameters(
net,
0,
1,
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=max_trafo_loading)
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", np.array([10, 0]))
pp.create_ext_grid(net, 0)
pp.create_polynomial_cost(net, 0, "ext_grid", np.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
for init in ["pf", "flat"]:
pp.runopp(net, verbose=False, init=init)
assert net["OPF_converged"]
# assert and check result
logger.debug("test_opf_sgen_loading")
logger.debug("res_sgen:\n%s" % net.res_sgen)
logger.debug("res_line.loading_percent:\n%s" %
net.res_line.loading_percent)
assert max(net.res_line.loading_percent) - max_line_loading < 1e-2
logger.debug("res_trafo.loading_percent:\n%s" %
net.res_trafo.loading_percent)
assert max(net.res_trafo.loading_percent) < max_trafo_loading
assert max(net.res_bus.vm_pu) < vm_max
assert min(net.res_bus.vm_pu) > vm_min
# check connectivity check
pp.runopp(net, verbose=False, check_connectivity=True)
def test_opf_varying_max_line_loading():
""" Testing a simple network with transformer for loading
constraints with OPF using a generator """
# boundaries
vm_max = 1.5
vm_min = 0.5
max_trafo_loading = 800
max_line_loading = 13
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_transformer_from_parameters(
net,
0,
1,
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=max_trafo_loading)
pp.create_sgen(net,
3,
p_kw=-100,
controllable=True,
max_p_kw=-5,
min_p_kw=-150,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_sgen(net,
2,
p_kw=-100,
controllable=True,
max_p_kw=-5,
min_p_kw=-150,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_polynomial_cost(net, 0, "sgen", np.array([-10, 0]))
pp.create_polynomial_cost(net, 1, "sgen", np.array([-10, 0]))
pp.create_ext_grid(net, 0)
pp.create_polynomial_cost(net, 0, "ext_grid", np.array([-.1, 0]))
pp.create_line_from_parameters(net,
1,
2,
1,
name="line1",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.200,
x_ohm_per_km=0.1159876,
max_loading_percent=20)
pp.create_line_from_parameters(net,
1,
3,
1,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.100,
x_ohm_per_km=0.1159876,
max_loading_percent=10)
# run OPF
pp.runopp(net, verbose=False, init="flat")
assert net["OPF_converged"]
assert sum(net["_ppc"]["branch"][:, 5] -
np.array([0.02771281 + 0.j, 0.00692820 + 0.j, 0.12800000 +
0.j])) < 1e-8
# assert and check result
logger.debug("test_opf_sgen_loading")
logger.debug("res_sgen:\n%s" % net.res_sgen)
logger.debug("res_line.loading_percent:\n%s" %
net.res_line.loading_percent)
assert net.res_line.loading_percent.at[0] - 20 < 1e-2
logger.debug("res_line.loading_percent:\n%s" %
net.res_line.loading_percent)
assert net.res_line.loading_percent.at[1] - 10 < 1e-2
def test_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", np.array([10, 0]))
pp.create_ext_grid(net, 0)
pp.create_polynomial_cost(net, 0, "ext_grid", np.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_opf_gen_voltage():
""" Testing a simple network with transformer for voltage
constraints with OPF using a generator """
# boundaries:
vm_max = 1.05
vm_min = 0.95
# ceate 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=200)
pp.create_gen(net,
3,
p_kw=-10,
controllable=True,
max_p_kw=0,
min_p_kw=-25,
max_q_kvar=500,
min_q_kvar=-500)
pp.create_polynomial_cost(net, 0, "gen", np.array([-10, 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=100000)
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=100000)
# run OPF
for init in ["pf", "flat"]:
pp.runopp(net, verbose=False, init=init)
assert net["OPF_converged"]
# check and assert result
logger.debug("test_opf_gen_voltage")
logger.debug("res_gen:\n%s" % net.res_gen)
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
def build_case_grid(self):
grid = pp.create_empty_network()
# Substation buses 1
bus0 = pp.create_bus(
grid,
vn_kv=2 * self.base_unit_v / 1000,
min_vm_pu=1.0,
max_vm_pu=1.02,
name="bus-0-0",
)
bus1 = pp.create_bus(
grid,
vn_kv=self.base_unit_v / 1000,
min_vm_pu=1.0,
max_vm_pu=1.02,
name="bus-1-1",
)
bus2 = pp.create_bus(
grid,
vn_kv=self.base_unit_v / 1000,
min_vm_pu=1.0,
max_vm_pu=1.02,
name="bus-2-2",
)
bus3 = pp.create_bus(
grid,
vn_kv=self.base_unit_v / 1000,
min_vm_pu=1.0,
max_vm_pu=1.02,
name="bus-3-3",
)
# Substation buses 2
pp.create_bus(
grid,
vn_kv=2 * self.base_unit_v / 1000,
min_vm_pu=1.0,
max_vm_pu=1.02,
name="bus-4-0",
)
pp.create_bus(
grid,
vn_kv=self.base_unit_v / 1000,
min_vm_pu=1.0,
max_vm_pu=1.02,
name="bus-5-1",
)
pp.create_bus(
grid,
vn_kv=self.base_unit_v / 1000,
min_vm_pu=1.0,
max_vm_pu=1.02,
name="bus-6-2",
)
pp.create_bus(
grid,
vn_kv=self.base_unit_v / 1000,
min_vm_pu=1.0,
max_vm_pu=1.02,
name="bus-7-3",
)
# Transformer
pp.create_transformer_from_parameters(
grid,
hv_bus=bus0,
lv_bus=bus1,
name="trafo-0",
sn_mva=3.5,
vn_hv_kv=2 * self.base_unit_v / 1000,
vn_lv_kv=self.base_unit_v / 1000,
vk_percent=12.5,
vkr_percent=0.0,
pfe_kw=0.0,
i0_percent=0.0,
shift_degree=0.0,
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus1,
bus2,
length_km=1.0,
r_ohm_per_km=0.0,
x_ohm_per_km=1.0 / 4.0 * self.base_unit_z,
c_nf_per_km=0.0,
max_i_ka=self.convert_per_unit_to_ka(5.0),
name="line-0",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus2,
bus3,
length_km=1.0,
r_ohm_per_km=0.0,
x_ohm_per_km=1.0 / 6.0 * self.base_unit_z,
c_nf_per_km=0.0,
max_i_ka=self.convert_per_unit_to_ka(5.0),
name="line-1",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus3,
bus1,
length_km=1.0,
r_ohm_per_km=0.0,
x_ohm_per_km=1.0 / 5.0 * self.base_unit_z,
c_nf_per_km=0.0,
max_i_ka=self.convert_per_unit_to_ka(4.0),
name="line-2",
type="ol",
max_loading_percent=100.0,
)
# Loads
pp.create_load(grid, bus1, p_mw=2, name="load-0", controllable=False)
pp.create_load(grid, bus2, p_mw=3, name="load-1", controllable=False)
pp.create_load(grid, bus3, p_mw=6, name="load-2", controllable=False)
# Generators
pp.create_gen(
grid,
bus0,
p_mw=0,
min_p_mw=0,
max_p_mw=1,
vm_pu=1.01,
name="gen-0",
controllable=True,
slack=True,
)
pp.create_gen(
grid,
bus2,
p_mw=0,
min_p_mw=0,
max_p_mw=5,
vm_pu=1.01,
name="gen-1",
controllable=True,
)
pp.create_gen(
grid,
bus3,
p_mw=0,
min_p_mw=0,
max_p_mw=8,
vm_pu=1.01,
name="gen-2",
controllable=True,
)
# External grids
pp.create_ext_grid(
grid,
bus0,
va_degree=0.0,
name="ext-grid-0",
max_p_mw=3.0,
min_p_mw=0.0,
max_loading_percent=100.0,
)
grid.trafo[
"b_pu"] = 28.0 # Empirically: x = vk_percent / 100 * 1 / sn_mva
grid.trafo["max_p_pu"] = 3.5 # sn_mva
return grid
vn_lv_kv=0.4, vk_percent=6,
vkr_percent=0.78125, pfe_kw=2.7,
i0_percent=0.16875, shift_degree=0,
tap_side='lv', 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, vector_group=vector_group,
parallel=1, tap_pos=tap_ps,
index=pp.get_free_id(net.trafo)+1)
pp.create_line_from_parameters(net, b2, b3, length_km=0.5, r_ohm_per_km=0.1941, x_ohm_per_km=0.07476991,
c_nf_per_km=1160., max_i_ka=0.421,
endtemp_degree=70.0, r0_ohm_per_km=0.7766,
x0_ohm_per_km=0.2990796,
c0_nf_per_km=496.2,
index=pp.get_free_id(net.line)+1)
if case == "bal_wye":
# Symmetric Load
pp.create_load(net, b3, 0.08, 0.012, type='wye')
elif case == "delta_wye":
# Unsymmetric Light Load
pp.create_asymmetric_load(net, b3, p_a_mw=0.0044, q_a_mvar=0.0013, p_b_mw=0.0044, q_b_mvar=0.0013,
p_c_mw=0.0032, q_c_mvar=0.0013, type='wye')
pp.create_asymmetric_load(net, b3, p_a_mw=0.0300, q_a_mvar=0.0048, p_b_mw=0.0280, q_b_mvar=0.0036,
p_c_mw=0.027, q_c_mvar=0.0043, type='delta')
elif case == "wye":
# Unsymmetric Heavy Load
pp.create_asymmetric_load(net, b3, p_a_mw=0.0300, q_a_mvar=0.0048, p_b_mw=0.0280, q_b_mvar=0.0036,
# globals()[name.lower()] = value
#Lines definition
Lines = {}
with open('Line_data.csv', 'r') as Line_data:
for index, row in enumerate(csv.reader(Line_data)):
Lines["Line{0}".format(index)] = pp.create_line_from_parameters(
net,
int(row[0]),
int(row[1]),
length_km=float(row[2]),
r_ohm_per_km=float(row[3]),
x_ohm_per_km=float(row[4]),
c_nf_per_km=float(row[5]),
max_i_ka=float(row[6]),
name=None,
index=index,
type=str(row[9]),
in_service=(row[10] == "True"),
df=int(row[11]),
parallel=int(row[12]),
g_us_per_km=float(row[13]),
max_loading_percent=float(row[14]))
assert len(Lines) > 0
print(Lines["Line0"])
for name, value in Lines.items():
globals()[name.lower()] = value
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
print(net.bus) # show bus table
### Lines ###
lines = pd.read_csv('data/Line.csv',names=['from_bus','to_bus','power_rating','voltage_rating',
'freq_rating','length','-','r','x','b','--','---','i_max','p_max','s_max','area'])
for line in lines.itertuples(index=True, name='Pandas'):
from_bus = getattr(line, "from_bus")
to_bus = getattr(line, "to_bus")
length = getattr(line, "length")
r_ohm_per_km = getattr(line, "r")
x_ohm_per_km = getattr(line, "x")
c_nf_per_km = getattr(line, "r")/(2*math.pi*freq)
max_i_ka = getattr(line, "i_max")/1e3
line_num = getattr(line, "Index")
pp.create_line_from_parameters(net,from_bus-1,to_bus-1,
length_km=length,r_ohm_per_km=r_ohm_per_km,x_ohm_per_km=x_ohm_per_km,
c_nf_per_km=c_nf_per_km,max_i_ka=max_i_ka,name='Line %s' % line_num)
'''pp.create_line(net,from_bus-1,to_bus-1,length_km=length,std_type="NAYY 4x50 SE",
name='Line %s' % line_num)'''
print(net.line) # show line table
### Shunt ###
shunts = pd.read_csv('data/Shunt.csv',names=['bus_num','power_rating','voltage_rating','freq_rating',
'conductance','susceptance'],index_col=False)
for shunt in shunts.itertuples(index=True, name='Pandas'):
bus_num = getattr(shunt, "bus_num")
q_mvar = getattr(shunt, "susceptance")
shunt_num = getattr(shunt, "Index")
pp.create_shunt(net, bus_num-1, p_mw=0, q_mvar=q_mvar, name='Shunt %s' % shunt_num)
print(net.shunt) # show shunt table
def test_3bus_with_transformer():
np.random.seed(12)
# 1. Create network
net = pp.create_empty_network()
pp.create_bus(net, name="bus1", vn_kv=10.)
pp.create_bus(net, name="bus2", vn_kv=10.)
pp.create_bus(net, name="bus3", vn_kv=10.)
pp.create_bus(net, name="bus4", vn_kv=110.)
pp.create_ext_grid(net, bus=3, vm_pu=1.01)
pp.create_line_from_parameters(net, 0, 1, 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, 0, 2, 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, 1, 2, 1, r_ohm_per_km=.03, x_ohm_per_km=.08, c_nf_per_km=0.,
max_i_ka=1)
pp.create_std_type(net, {"sn_mva": 25, "vn_hv_kv": 110, "vn_lv_kv": 10, "vk_percent": 10.04,
"vkr_percent": 0.276, "pfe_kw": 28.51, "i0_percent": 0.073, "shift_degree": 150,
"tap_side": "hv", "tap_neutral": 0, "tap_min": -9, "tap_max": 9, "tap_step_degree": 0,
"tap_step_percent": 1.5, "tap_phase_shifter": False},
"25 MVA 110/10 kV v1.4.3 and older", element="trafo")
pp.create_transformer(net, 3, 0, std_type="25 MVA 110/10 kV v1.4.3 and older")
pp.create_load(net, bus=1, p_mw=0.45, q_mvar=0.3)
pp.create_load(net, bus=2, p_mw=0.35, q_mvar=0.2)
pp.runpp(net, calculate_voltage_angles=True)
pp.create_measurement(net, "v", "bus", r2(net.res_bus.vm_pu.iloc[0], .004), .004, element=0)
pp.create_measurement(net, "v", "bus", r2(net.res_bus.vm_pu.iloc[1], .004), .004, element=1)
pp.create_measurement(net, "v", "bus", r2(net.res_bus.vm_pu.iloc[3], .004), .004, element=3)
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[1], .01), .01, element=1)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[1], .01), .01, element=1)
pp.create_measurement(net, "p", "bus", -r2(net.res_bus.p_mw.iloc[2], .01), .010, element=2)
pp.create_measurement(net, "q", "bus", -r2(net.res_bus.q_mvar.iloc[2], .01), .01, element=2)
pp.create_measurement(net, "p", "bus", 0., 0.001, element=0)
pp.create_measurement(net, "q", "bus", 0., 0.001, element=0)
pp.create_measurement(net, "p", "line", r2(net.res_line.p_from_mw.iloc[0], .008), .008, 0, 0)
pp.create_measurement(net, "p", "line", r2(net.res_line.p_from_mw.iloc[1], .008), .008, 1, 0)
pp.create_measurement(net, "p", "trafo", r2(net.res_trafo.p_hv_mw.iloc[0], .01), .01,
side="hv", element=0) # transformer meas.
pp.create_measurement(net, "q", "trafo", r2(net.res_trafo.q_hv_mvar.iloc[0], .01), .01,
side=3, element=0) # at hv side
# 2. Do state estimation
success = estimate(net, init='slack', tolerance=5e-5, maximum_iterations=10, calculate_voltage_angles=True)
v_result = net.res_bus_est.vm_pu.values
delta_result = net.res_bus_est.va_degree.values
diff_v = net.res_bus.vm_pu.values - v_result
diff_delta = net.res_bus.va_degree.values - delta_result
assert success
assert (np.nanmax(abs(diff_v)) < 6e-4)
assert (np.nanmax(abs(diff_delta)) < 1.4e-4)
# Backwards check. Use state estimation results for power flow and check for equality
net.load.drop(net.load.index, inplace=True)
net.ext_grid.vm_pu = net.res_bus_est.vm_pu.iloc[net.ext_grid.bus.iloc[0]]
pp.create_load(net, 0, net.res_bus_est.p_mw.iloc[0], net.res_bus_est.q_mvar.iloc[0])
pp.create_load(net, 1, net.res_bus_est.p_mw.iloc[1], net.res_bus_est.q_mvar.iloc[1])
pp.create_load(net, 2, net.res_bus_est.p_mw.iloc[2], net.res_bus_est.q_mvar.iloc[2])
_compare_pf_and_se_results(net)
for load in energy_consumer_list:
bus, way_terminals = find_attached_busbar(load)
bus_name = bus[0].name
bus_pp = pp.get_element_index(net, "bus", bus_name)
pp.create_load(net, name=load.name, bus=bus_pp, p_mw=load.P)
# Line
for line in AC_lines_list:
bus_list, way_terminals = find_attached_busbar(line)
from_bus = pp.get_element_index(net, "bus", bus_list[0].name)
to_bus = pp.get_element_index(net, "bus", bus_list[1].name)
pp.create_line_from_parameters(net,
name=line.name,
from_bus=from_bus,
to_bus=to_bus,
length_km=line.lenght,
r_ohm_per_km=line.r,
x_ohm_per_km=line.x,
c_nf_per_km=0,
max_i_ka=0)
# Switch
for switch in breaker_list:
bus, way_terminals = find_attached_busbar(switch)
if switch.state == 'false':
state = False
else:
state = True
if isinstance(bus, list):
from_bus = pp.get_element_index(net, "bus", bus[0].name)
to_bus = pp.get_element_index(net, "bus", bus[1].name)
if ACLineSegmentValue[elementa].name == NodeValue[
elementb].conn_eqp[elementc]:
connected_bus.append(NodeValue[elementb].name)
for elementa in range(len(ACLineSegmentValue)):
if elementa == 0:
bus_1 = pp.get_element_index(net, "bus", connected_bus[elementa])
bus_2 = pp.get_element_index(net, "bus", connected_bus[elementa + 1])
if elementa == 1:
bus_1 = pp.get_element_index(net, "bus", connected_bus[elementa + 1])
bus_2 = pp.get_element_index(net, "bus", connected_bus[elementa + 2])
name = ACLineSegmentValue[elementa].name
line = pp.create_line_from_parameters(net, bus_1, bus_2, length, r, x, c,
'NaN', name)
print("\n" 'Line')
print(net.line)
'''
# To create the Load in pandapower
'''
'''
This is very basic logic that I have implemtneted, I have searched for name
of load from dictionary connected to particular node.
'''
for elementa in range(len(ConsumerValues)):
p_mw = float(ConsumerValues[elementa].P)
q_mw = float(ConsumerValues[elementa].Q)
def test_cost_mixed():
""" 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,
max_q_kvar=50,
max_p_kw=100,
min_p_kw=50,
min_q_kvar=-50)
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)
# testing some combinations
pp.create_polynomial_cost(net, 0, "gen", np.array([0, 1, 0]))
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost == -net.res_gen.p_kw.values
net.polynomial_cost.c.at[0] = np.array([[1, 0, 0]])
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost - net.res_gen.p_kw.values**2 < 1e-5
net.polynomial_cost.c.at[0] = np.array([[1, 0, 1]])
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost - net.res_gen.p_kw.values**2 - 1 < 1e-5
net.load.controllable.at[0] = True
pp.runopp(net, verbose=False)
assert net.res_cost - net.res_gen.p_kw.values**2 - 1 < 1e-5
pp.create_piecewise_linear_cost(net,
0,
"load",
np.array([[0, 0], [100, 100]]),
type="p")
pp.runopp(net, verbose=False)
assert net.res_cost - net.res_gen.p_kw.values**2 - 1 - net.res_load.p_kw.values < 1e-5
0])) #Brighton
pp.create_polynomial_cost(net, 0, 'gen', np.array([0, 14 / 1000, 0])) #Alta
pp.create_polynomial_cost(net, 1, 'gen', np.array([0, 15 / 1000,
0])) #Park City
pp.create_polynomial_cost(net, 2, 'gen', np.array([0, 30 / 1000,
0])) #Solitude
pp.create_polynomial_cost(net, 3, 'gen', np.array([0, 35 / 1000,
0])) #Sundancde
pp.create_polynomial_cost(net, 4, 'gen', np.array([0, 10 / 1000,
0])) #Sundancde
pp.create_line_from_parameters(net,
name='line1',
from_bus=0,
to_bus=1,
geodata=([0, 0], [25, 0]),
length_km=1,
r_ohm_per_km=.00281,
x_ohm_per_km=0.0281,
c_nf_per_km=0.00712,
max_i_ka=1,
max_loading_percent=100)
pp.create_line_from_parameters(net,
name='line2',
from_bus=0,
to_bus=3,
geodata=([0, 0], [50, 50]),
length_km=1,
r_ohm_per_km=.00304,
x_ohm_per_km=0.0304,
c_nf_per_km=0.00658,
max_i_ka=1)
D = pp.create_bus(net, vn_kv=150.0, name="D", in_service=True)
E = pp.create_bus(net, vn_kv=150.0, name="E", in_service=True)
F = pp.create_bus(net, vn_kv=15.0, name="F", in_service=True)
# list of Loads:
pp.create_load(net, bus=D, p_mw=100.0, q_mvar=30.0, name="D", in_service=True)
pp.create_load(net, bus=E, p_mw=400.0, q_mvar=120.0, name="E", in_service=True)
# List of Shunts:
# list of Lines:
pp.create_line_from_parameters(net,
from_bus=B,
to_bus=C,
name="B-C",
length_km=1,
r_ohm_per_km=1.5,
x_ohm_per_km=15.0,
max_i_ka=2.051113,
c_nf_per_km=477.464829,
in_service=True)
pp.create_line_from_parameters(net,
from_bus=D,
to_bus=E,
name="D-E",
length_km=1,
r_ohm_per_km=4.0,
x_ohm_per_km=20.0,
max_i_ka=1.154701,
c_nf_per_km=381.971863,
in_service=True)
def from_ppc(ppc, f_hz=50, validate_conversion=False, **kwargs):
"""
This function converts pypower case files to pandapower net structure.
INPUT:
**ppc** : The pypower case file.
OPTIONAL:
**f_hz** (float, 50) - The frequency of the network.
**validate_conversion** (bool, False) - If True, validate_from_ppc is run after conversion.
For running the validation, the ppc must already contain the pypower
powerflow results or pypower must be importable.
****kwargs** keyword arguments for validate_from_ppc if validate_conversion is True
OUTPUT:
**net** : pandapower net.
EXAMPLE:
import pandapower.converter as pc
from pypower import case4gs
ppc_net = case4gs.case4gs()
net = pc.from_ppc(ppc_net, f_hz=60)
"""
# --- catch common failures
if Series(ppc['bus'][:, BASE_KV] <= 0).any():
logger.info('There are false baseKV given in the pypower case file.')
# --- general_parameters
baseMVA = ppc['baseMVA'] # MVA
omega = pi * f_hz # 1/s
MAX_VAL = 99999.
net = pp.create_empty_network(f_hz=f_hz, sn_mva=baseMVA)
# --- bus data -> create buses, sgen, load, shunt
for i in range(len(ppc['bus'])):
# create buses
pp.create_bus(net,
name=int(ppc['bus'][i, 0]),
vn_kv=ppc['bus'][i, 9],
type="b",
zone=ppc['bus'][i, 10],
in_service=bool(ppc['bus'][i, 1] != 4),
max_vm_pu=ppc['bus'][i, 11],
min_vm_pu=ppc['bus'][i, 12])
# create sgen, load
if ppc['bus'][i, 2] > 0:
pp.create_load(net,
i,
p_mw=ppc['bus'][i, 2],
q_mvar=ppc['bus'][i, 3],
controllable=False)
elif ppc['bus'][i, 2] < 0:
pp.create_sgen(net,
i,
p_mw=-ppc['bus'][i, 2],
q_mvar=-ppc['bus'][i, 3],
type="",
controllable=False)
elif ppc['bus'][i, 3] != 0:
pp.create_load(net,
i,
p_mw=ppc['bus'][i, 2],
q_mvar=ppc['bus'][i, 3],
controllable=False)
# create shunt
if ppc['bus'][i, 4] != 0 or ppc['bus'][i, 5] != 0:
pp.create_shunt(net,
i,
p_mw=ppc['bus'][i, 4],
q_mvar=-ppc['bus'][i, 5])
# unused data of ppc: Vm, Va (partwise: in ext_grid), zone
# --- gen data -> create ext_grid, gen, sgen
gen_lookup = DataFrame(nan,
columns=['element', 'element_type'],
index=range(len(ppc['gen'][:, 0])))
# if in ppc is only one gen -> numpy initially uses one dim array -> change to two dim array
if len(ppc["gen"].shape) == 1:
ppc["gen"] = array(ppc["gen"], ndmin=2)
for i in range(len(ppc['gen'][:, 0])):
current_bus_type, current_bus_idx, same_bus_gen_idx, first_same_bus_in_service_gen_idx, \
last_same_bus_in_service_gen_idx = _gen_bus_info(ppc, i)
# create ext_grid
if current_bus_type == 3:
if i == first_same_bus_in_service_gen_idx:
gen_lookup.element.loc[i] = pp.create_ext_grid(
net,
bus=current_bus_idx,
vm_pu=ppc['gen'][last_same_bus_in_service_gen_idx, 5],
va_degree=ppc['bus'][current_bus_idx, 8],
in_service=bool(ppc['gen'][i, 7] > 0),
max_p_mw=ppc['gen'][i, PMAX],
min_p_mw=ppc['gen'][i, PMIN],
max_q_mvar=ppc['gen'][i, QMAX],
min_q_mvar=ppc['gen'][i, QMIN])
gen_lookup.element_type.loc[i] = 'ext_grid'
if ppc['gen'][i, 4] > ppc['gen'][i, 3]:
logger.info(
'min_q_mvar of gen %d must be less than max_q_mvar but is not.'
% i)
if -ppc['gen'][i, 9] < -ppc['gen'][i, 8]:
logger.info(
'max_p_mw of gen %d must be less than min_p_mw but is not.'
% i)
else:
current_bus_type = 1
# create gen
elif current_bus_type == 2:
if i == first_same_bus_in_service_gen_idx:
gen_lookup.element.loc[i] = pp.create_gen(
net,
bus=current_bus_idx,
vm_pu=ppc['gen'][last_same_bus_in_service_gen_idx, 5],
p_mw=ppc['gen'][i, 1],
in_service=bool(ppc['gen'][i, 7] > 0),
controllable=True,
max_p_mw=ppc['gen'][i, PMAX],
min_p_mw=ppc['gen'][i, PMIN],
max_q_mvar=ppc['gen'][i, QMAX],
min_q_mvar=ppc['gen'][i, QMIN])
gen_lookup.element_type.loc[i] = 'gen'
if ppc['gen'][i, 1] < 0:
logger.info(
'p_mw of gen %d must be less than zero but is not.' %
i)
if ppc['gen'][i, 4] > ppc['gen'][i, 3]:
logger.info(
'min_q_mvar of gen %d must be less than max_q_mvar but is not.'
% i)
if -ppc['gen'][i, 9] < -ppc['gen'][i, 8]:
logger.info(
'max_p_mw of gen %d must be less than min_p_mw but is not.'
% i)
else:
current_bus_type = 1
# create sgen
if current_bus_type == 1:
gen_lookup.element.loc[i] = pp.create_sgen(
net,
bus=current_bus_idx,
p_mw=ppc['gen'][i, 1],
q_mvar=ppc['gen'][i, 2],
type="",
in_service=bool(ppc['gen'][i, 7] > 0),
max_p_mw=ppc['gen'][i, PMAX],
min_p_mw=ppc['gen'][i, PMIN],
max_q_mvar=ppc['gen'][i, QMAX],
min_q_mvar=ppc['gen'][i, QMIN],
controllable=True)
gen_lookup.element_type.loc[i] = 'sgen'
if ppc['gen'][i, 1] < 0:
logger.info(
'p_mw of sgen %d must be less than zero but is not.' % i)
if ppc['gen'][i, 4] > ppc['gen'][i, 3]:
logger.info(
'min_q_mvar of gen %d must be less than max_q_mvar but is not.'
% i)
if -ppc['gen'][i, 9] < -ppc['gen'][i, 8]:
logger.info(
'max_p_mw of gen %d must be less than min_p_mw but is not.'
% i)
# unused data of ppc: Vg (partwise: in ext_grid and gen), mBase, Pc1, Pc2, Qc1min, Qc1max,
# Qc2min, Qc2max, ramp_agc, ramp_10, ramp_30,ramp_q, apf
# --- branch data -> create line, trafo
for i in range(len(ppc['branch'])):
from_bus = pp.get_element_index(net,
'bus',
name=int(ppc['branch'][i, 0]))
to_bus = pp.get_element_index(net,
'bus',
name=int(ppc['branch'][i, 1]))
from_vn_kv = ppc['bus'][from_bus, 9]
to_vn_kv = ppc['bus'][to_bus, 9]
if (from_vn_kv == to_vn_kv) & ((ppc['branch'][i, 8] == 0) | (ppc['branch'][i, 8] == 1)) & \
(ppc['branch'][i, 9] == 0): # create line
Zni = ppc['bus'][to_bus, 9]**2 / baseMVA # ohm
max_i_ka = ppc['branch'][i, 5] / ppc['bus'][to_bus, 9] / sqrt(3)
if max_i_ka == 0.0:
max_i_ka = MAX_VAL
logger.debug(
"ppc branch rateA is zero -> Using MAX_VAL instead to calculate "
+ "maximum branch flow")
pp.create_line_from_parameters(
net,
from_bus=from_bus,
to_bus=to_bus,
length_km=1,
r_ohm_per_km=ppc['branch'][i, 2] * Zni,
x_ohm_per_km=ppc['branch'][i, 3] * Zni,
c_nf_per_km=ppc['branch'][i, 4] / Zni / omega * 1e9 / 2,
max_i_ka=max_i_ka,
type='ol',
max_loading_percent=100,
in_service=bool(ppc['branch'][i, 10]))
else: # create transformer
if from_vn_kv >= to_vn_kv:
hv_bus = from_bus
vn_hv_kv = from_vn_kv
lv_bus = to_bus
vn_lv_kv = to_vn_kv
tap_side = 'hv'
else:
hv_bus = to_bus
vn_hv_kv = to_vn_kv
lv_bus = from_bus
vn_lv_kv = from_vn_kv
tap_side = 'lv'
if from_vn_kv == to_vn_kv:
logger.warning(
'The pypower branch %d (from_bus, to_bus)=(%d, %d) is considered'
' as a transformer because of a ratio != 0 | 1 but it connects '
'the same voltage level', i, ppc['branch'][i, 0],
ppc['branch'][i, 1])
rk = ppc['branch'][i, 2]
xk = ppc['branch'][i, 3]
zk = (rk**2 + xk**2)**0.5
sn = ppc['branch'][i, 5]
if sn == 0.0:
sn = MAX_VAL
logger.debug(
"ppc branch rateA is zero -> Using MAX_VAL instead to calculate "
+ "apparent power")
ratio_1 = 0 if ppc['branch'][i, 8] == 0 else (ppc['branch'][i, 8] -
1) * 100
i0_percent = -ppc['branch'][i, 4] * 100 * baseMVA / sn
if i0_percent < 0:
logger.info(
'A transformer always behaves inductive consumpting but the '
'susceptance of pypower branch %d (from_bus, to_bus)=(%d, %d) is '
'positive.', i, ppc['branch'][i, 0], ppc['branch'][i, 1])
pp.create_transformer_from_parameters(
net,
hv_bus=hv_bus,
lv_bus=lv_bus,
sn_mva=sn,
vn_hv_kv=vn_hv_kv,
vn_lv_kv=vn_lv_kv,
vk_percent=sign(xk) * zk * sn * 100 / baseMVA,
vkr_percent=rk * sn * 100 / baseMVA,
max_loading_percent=100,
pfe_kw=0,
i0_percent=i0_percent,
shift_degree=ppc['branch'][i, 9],
tap_step_percent=abs(ratio_1),
tap_pos=sign(ratio_1),
tap_side=tap_side,
tap_neutral=0)
# unused data of ppc: rateB, rateC
# --- gencost -> create polynomial_cost, piecewise_cost
if 'gencost' in ppc:
if len(ppc['gencost'].shape) == 1:
# reshape gencost if only one gencost is given -> no indexError
ppc['gencost'] = ppc['gencost'].reshape((1, -1))
if ppc['gencost'].shape[0] <= gen_lookup.shape[0]:
idx_p = range(ppc['gencost'].shape[0])
idx_q = []
elif ppc['gencost'].shape[0] > gen_lookup.shape[0]:
idx_p = range(gen_lookup.shape[0])
idx_q = range(gen_lookup.shape[0], ppc['gencost'].shape[0])
if ppc['gencost'].shape[0] >= 2 * gen_lookup.shape[0]:
idx_p = range(gen_lookup.shape[0])
idx_q = range(gen_lookup.shape[0], 2 * gen_lookup.shape[0])
for idx in idx_p:
_create_costs(net, ppc, gen_lookup, 'p', idx)
for idx in idx_q:
_create_costs(net, ppc, gen_lookup, 'q', idx)
# areas are unconverted
if validate_conversion:
logger.setLevel(logging.DEBUG)
if not validate_from_ppc(ppc, net, **kwargs):
logger.error("Validation failed.")
net._options = {}
net._options["gen_lookup"] = gen_lookup
return net
def test_3bus():
# 1. Create network
net = pp.create_empty_network()
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_ext_grid(net, 0)
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_out_of_service_bus():
# Test case from book "Power System State Estimation", A. Abur, A. G. Exposito, p. 20ff.
# S_ref = 1 MVA (PP standard)
# V_ref = 1 kV
# Z_ref = 1 Ohm
# The example only had per unit values, but pandapower expects kV, MVA, kW, kVar
# Measurements should be in kW/kVar/A - Voltage in p.u.
# 1. Create network
net = pp.create_empty_network()
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_bus(net, name="bus4", vn_kv=1.,
in_service=0) # out-of-service bus test
pp.create_ext_grid(net, 0)
pp.create_line_from_parameters(net,
0,
1,
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,
0,
2,
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,
1,
2,
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=0) # V at bus 1
pp.create_measurement(net, "v", "bus", .968, .004, bus=1) # V at bus 2
pp.create_measurement(net, "p", "bus", -501, 10, 1) # P at bus 2
pp.create_measurement(net, "q", "bus", -286, 10, 1) # Q at bus 2
pp.create_measurement(net, "p", "line", 888, 8, 0,
0) # Pline (bus 1 -> bus 2) at bus 1
pp.create_measurement(net, "p", "line", 1173, 8, 0,
1) # Pline (bus 1 -> bus 3) at bus 1
pp.create_measurement(net, "q", "line", 568, 8, 0,
0) # Qline (bus 1 -> bus 2) at bus 1
pp.create_measurement(net, "q", "line", 663, 8, 0,
1) # Qline (bus 1 -> bus 3) at bus 1
# 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([[0.9996, 0.9741, 0.9438, np.nan]])
diff_v = target_v - v_result
target_delta = np.array([[0., -1.2475, -2.7457, np.nan]])
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_cost_mixed():
""" Testing a very simple network for the resulting cost value
constraints with OPF """
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_mw=-0.1,
controllable=True,
min_p_mw=0.005,
max_p_mw=0.15,
max_q_mvar=.05,
min_q_mvar=-.05)
pp.create_ext_grid(net, 0)
pp.create_load(net,
1,
p_mw=0.02,
controllable=False,
max_q_mvar=.05,
max_p_mw=0.1,
min_p_mw=0.0050,
min_q_mvar=-.05)
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)
# testing some combinations
pp.create_poly_cost(net, 0, "gen", cp1_eur_per_mw=1)
pp.runopp(net)
assert net["OPF_converged"]
assert np.isclose(net.res_cost, net.res_gen.p_mw.values[0])
net.poly_cost.cp1_eur_per_mw.at[0] = 0
net.poly_cost.cp2_eur_per_mw2.at[0] = 1
pp.runopp(net)
assert net["OPF_converged"]
assert np.isclose(net.res_cost, net.res_gen.p_mw.values**2)
net.poly_cost.cp0_eur.at[0] = 1
pp.runopp(net)
assert net["OPF_converged"]
assert np.isclose(net.res_cost, net.res_gen.p_mw.values**2 + 1)
net.load.controllable.at[0] = True
pp.runopp(net)
assert np.isclose(net.res_cost, net.res_gen.p_mw.values**2 + 1)
net.load.controllable.at[0] = False
net.pwl_cost.drop(net.pwl_cost.index, inplace=True)
pp.create_pwl_cost(net,
0,
"ext_grid", [[-1000, 0, -2000], [0, 1000, 2000]],
power_type="p")
net.poly_cost.cp1_eur_per_mw.at[0] = 1000
net.poly_cost.cp2_eur_per_mw2.at[0] = 0
pp.runopp(net)
assert np.isclose(net.res_ext_grid.p_mw.values[0], 0, atol=1e-4)
assert np.isclose(net.res_cost,
net.res_gen.p_mw.values[0] * 1000,
atol=1e-3)
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_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_ext_grid(net, 5)
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 build_case_grid(self):
grid = pp.create_empty_network()
# Substation bus 1
bus0 = pp.create_bus(grid,
vn_kv=self.base_unit_v / 1000,
name="bus-0-0")
bus1 = pp.create_bus(grid,
vn_kv=self.base_unit_v / 1000,
name="bus-1-1")
bus2 = pp.create_bus(grid,
vn_kv=self.base_unit_v / 1000,
name="bus-2-2")
# Substation bus 2
pp.create_bus(grid, vn_kv=self.base_unit_v / 1000, name="bus-3-0")
pp.create_bus(grid, vn_kv=self.base_unit_v / 1000, name="bus-4-1")
pp.create_bus(grid, vn_kv=self.base_unit_v / 1000, name="bus-5-2")
pp.create_line_from_parameters(
grid,
bus0,
bus1,
length_km=1.0,
r_ohm_per_km=0.01 * self.base_unit_z,
x_ohm_per_km=1.0 / 3.0 * self.base_unit_z,
c_nf_per_km=0.0,
max_i_ka=self.convert_per_unit_to_ka(1.0),
name="line-0",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus0,
bus2,
length_km=1.0,
r_ohm_per_km=0.01 * self.base_unit_z,
x_ohm_per_km=1.0 / 2.0 * self.base_unit_z,
c_nf_per_km=0.0,
max_i_ka=self.convert_per_unit_to_ka(1.0),
name="line-1",
type="ol",
max_loading_percent=100.0,
)
pp.create_line_from_parameters(
grid,
bus1,
bus2,
length_km=1.0,
r_ohm_per_km=0.01 * self.base_unit_z,
x_ohm_per_km=1.0 / 2.0 * self.base_unit_z,
c_nf_per_km=0.0,
max_i_ka=self.convert_per_unit_to_ka(1.0),
name="line-2",
type="ol",
max_loading_percent=100.0,
)
pp.create_load(
grid,
bus1,
p_mw=self.convert_per_unit_to_mw(0.5),
name="load-0",
controllable=False,
)
pp.create_load(
grid,
bus2,
p_mw=self.convert_per_unit_to_mw(1.0),
name="load-1",
controllable=False,
)
pp.create_gen(
grid,
bus0,
p_mw=self.convert_per_unit_to_mw(1.5),
min_p_mw=self.convert_per_unit_to_mw(0.0),
max_p_mw=self.convert_per_unit_to_mw(2.0),
slack=True,
name="gen-0",
)
return grid
