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