def test_shunt(): net = pp.create_empty_network() b1 = pp.create_bus(net, 110) b2 = pp.create_bus(net, 110) pp.create_ext_grid(net, b1, s_sc_max_mva=300, rx_max=0.1) # pp.create_shunt(net, b2, 25, 0, 6) pp.create_line(net, b1, b2, std_type="305-AL1/39-ST1A 110.0", length_km=10) sc.calc_sc(net, tk_s=2.5e-2)
def test_2bus_network_singel_oos_bus(net): # -o---x---o b1 = pp.create_bus(net, vn_kv=110) net.bus.loc[5, "in_service"] = False pp.create_line(net, from_bus=5, to_bus=b1, length_km=10.0, std_type="example_type") pp.create_asymmetric_load(net, b1, p_a_mw=-5, q_a_mvar=5, p_b_mw=-1, q_b_mvar=1.5, p_c_mw=-1, q_c_mvar=.5) pp.add_zero_impedance_parameters(net) runpp_3ph_with_consistency_checks(net) assert net['converged']
def test_opf_no_controllables_vs_pf(): """ Comparing the calculation results of PF and OPF in a simple network with non-controllable elements """ # boundaries vm_max = 1.3 vm_min = 0.9 max_line_loading_percent = 100 # create network net = pp.create_empty_network() b1 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min) b2 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min) pp.create_line(net, b1, b2, length_km=5, std_type="NAYY 4x50 SE", max_loading_percent=max_line_loading_percent) # test elements static pp.create_ext_grid(net, b2) pp.create_load(net, b1, p_mw=.0075, controllable=False) pp.create_sgen(net, b1, p_mw=0.025, controllable=False, min_p_mw=0.01, max_p_mw=0.025, max_q_mvar=0.025, min_q_mvar=-0.025) # testing cost assignment (for non-controllable elements - see Gitlab Issue #27) pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=3) pp.create_poly_cost(net, 0, "load", cp1_eur_per_mw=-3) pp.create_poly_cost(net, 0, "sgen", cp1_eur_per_mw=2) # do calculations pp.runopp(net) assert net["OPF_converged"] res_opf_line_loading = net.res_line.loading_percent res_opf_bus_voltages = net.res_bus.vm_pu pp.runpp(net) assert net["converged"] res_pf_line_loading = net.res_line.loading_percent res_pf_bus_voltages = net.res_bus.vm_pu # assert calculation behaviour assert np.isclose(res_opf_line_loading, res_pf_line_loading).all() assert np.isclose(res_opf_bus_voltages, res_pf_bus_voltages).all()
def test_volt_dep_load_at_inactive_bus(): # create empty net net = pp.create_empty_network() # create buses bus1 = pp.create_bus(net, index=0, vn_kv=20., name="Bus 1") bus2 = pp.create_bus(net, index=1, vn_kv=0.4, name="Bus 2") bus3 = pp.create_bus(net, index=3, in_service=False, vn_kv=0.4, name="Bus 3") bus4 = pp.create_bus(net, index=4, vn_kv=0.4, name="Bus 4") bus4 = pp.create_bus(net, index=5, vn_kv=0.4, name="Bus 4") # create bus elements pp.create_ext_grid(net, bus=bus1, vm_pu=1.02, name="Grid Connection") pp.create_load(net, bus=4, p_kw=100, q_kvar=50, name="Load3", const_i_percent=100) pp.create_load(net, bus=5, p_kw=100, q_kvar=50, name="Load4") # create branch elements trafo = pp.create_transformer(net, hv_bus=bus1, lv_bus=bus2, std_type="0.4 MVA 20/0.4 kV", name="Trafo") line1 = pp.create_line(net, from_bus=1, to_bus=3, length_km=0.1, std_type="NAYY 4x50 SE", name="Line") line2 = pp.create_line(net, from_bus=1, to_bus=4, length_km=0.1, std_type="NAYY 4x50 SE", name="Line") line3 = pp.create_line(net, from_bus=1, to_bus=5, length_km=0.1, std_type="NAYY 4x50 SE", name="Line") pp.runpp(net) assert not np.isnan(net.res_load.p_kw.at[1]) assert not np.isnan(net.res_bus.p_kw.at[5]) assert net.res_bus.p_kw.at[3] == 0
def test_2bus_network_isolated_net_part(net): # -o---o o---o b1 = pp.create_bus(net, vn_kv=110) b2 = pp.create_bus(net, vn_kv=110) pp.create_line(net, from_bus=b1, to_bus=b2, length_km=50.0, std_type="example_type") pp.create_asymmetric_load(net, b2, 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.add_zero_impedance_parameters(net) runpp_3ph_with_consistency_checks(net) assert net['converged'] check_it(net)
def test_add_element_and_init_results(): net = simple_four_bus_system() pp.runpp(net, init="flat") pp.create_bus(net, vn_kv=20.) pp.create_line(net, from_bus=2, to_bus=3, length_km=1, name="new line" + str(1), std_type="NAYY 4x150 SE") pp.runpp(net, init="results")
def test_1ph_with_switches(): net = pp.create_empty_network() vc = "Yy" l1, l2, _ = add_network(net, vc) sc.calc_sc(net, fault="1ph", case="max") pp.create_line(net, net.line.to_bus.at[l2], net.line.from_bus.at[l1], length_km=15, std_type="unsymmetric_line_type", parallel=2.) pp.add_zero_impedance_parameters(net) pp.create_switch(net, bus=net.line.to_bus.at[l2], element=l2, et="l", closed=False) sc.calc_sc(net, fault="1ph", case="max") check_results(net, vc, [0.52209347338, 2.0620266652, 2.3255761263, 2.3066467489])
def feeder_network(): net = pp.create_empty_network() current_bus = pp.create_bus(net, vn_kv=20.) pp.create_ext_grid(net, current_bus) for length in [12, 6, 8]: new_bus = pp.create_bus(net, vn_kv=20.) pp.create_line(net, current_bus, new_bus, length_km=length, std_type="NA2XS2Y 1x185 RM/25 12/20 kV") current_bus = new_bus pp.create_line(net, current_bus, 0, length_km=5, std_type="NA2XS2Y 1x185 RM/25 12/20 kV") return net
def test_ext_grid_and_gen_at_one_bus(): net = pp.create_empty_network() b1 = pp.create_bus(net, vn_kv=110) b2 = pp.create_bus(net, vn_kv=110) pp.create_ext_grid(net, b1, vm_pu=1.01) pp.create_line(net, b1, b2, 1., std_type="305-AL1/39-ST1A 110.0") pp.create_load(net, bus=b2, p_mw=3.5, q_mvar=1) runpp_with_consistency_checks(net) q = net.res_ext_grid.q_mvar.sum() ##create two gens at the slack bus g1 = pp.create_gen(net, b1, vm_pu=1.01, p_mw=1) g2 = pp.create_gen(net, b1, vm_pu=1.01, p_mw=1) runpp_with_consistency_checks(net) # all the reactive power previously provided by the ext_grid is now provided by the generators assert np.isclose(net.res_ext_grid.q_mvar.values, 0) assert np.isclose(net.res_gen.q_mvar.sum(), q) # since no Q-limits were set, reactive power is distributed equally to both generators assert np.isclose(net.res_gen.q_mvar.at[g1], net.res_gen.q_mvar.at[g2]) # set reactive power limits at the generators net.gen["max_q_mvar"] = [0.1, 0.01] net.gen["min_q_mvar"] = [-0.1, -0.01] runpp_with_consistency_checks(net) # g1 now has 10 times the reactive power of g2 in accordance with the different Q ranges assert np.isclose(net.res_gen.q_mvar.at[g1], net.res_gen.q_mvar.at[g2] * 10) # all the reactive power is still provided by the generators, because Q-lims are not enforced assert np.allclose(net.res_ext_grid.q_mvar.values, [0]) assert np.isclose(net.res_gen.q_mvar.sum(), q) # now enforce Q-lims runpp_with_consistency_checks(net, enforce_q_lims=True) # both generators are at there lower limit with regard to the reactive power assert np.allclose(net.res_gen.q_mvar.values, net.gen.max_q_mvar.values) # the total reactive power remains unchanged, but the rest of the power is now provided by the ext_grid assert np.isclose(net.res_gen.q_mvar.sum() + net.res_ext_grid.q_mvar.sum(), q) # second ext_grid at the slack bus pp.create_ext_grid(net, b1, vm_pu=1.01) runpp_with_consistency_checks(net, enforce_q_lims=False) # gens still have the correct active power assert np.allclose(net.gen.p_mw.values, net.res_gen.p_mw.values) # slack active power is evenly distributed to both ext_grids assert np.isclose(net.res_ext_grid.p_mw.values[0], net.res_ext_grid.p_mw.values[1]) # q limits at the ext_grids are not enforced net.ext_grid["max_q_mvar"] = [0.1, 0.01] net.ext_grid["min_q_mvar"] = [-0.1, -0.01] runpp_with_consistency_checks(net, enforce_q_lims=True) assert net.res_ext_grid.q_mvar.values[0] > net.ext_grid.max_q_mvar.values[0] assert np.allclose(net.res_gen.q_mvar.values, net.gen.max_q_mvar.values)
def simple_four_bus_system(): """ This function creates a simple four bus system with two radial low voltage nodes connected to \ a medium voltage slack bus. At both low voltage nodes the a load and a static generator is \ connected. OUTPUT: **net** - Returns the required four bus system EXAMPLE: import pandapower.networks as pn net_simple_four_bus = pn.simple_four_bus_system() """ net = pp.create_empty_network() busnr1 = pp.create_bus(net, name="bus1ref", vn_kv=10, geodata=[0, 0]) pp.create_ext_grid(net, busnr1) busnr2 = pp.create_bus(net, name="bus2", vn_kv=.4, geodata=[0, -1]) pp.create_transformer(net, busnr1, busnr2, name="transformer", std_type="0.25 MVA 10/0.4 kV") busnr3 = pp.create_bus(net, name="bus3", vn_kv=.4, geodata=[0, -2]) pp.create_line(net, busnr2, busnr3, name="line1", length_km=0.50000, std_type="NAYY 4x50 SE") busnr4 = pp.create_bus(net, name="bus4", vn_kv=.4, geodata=[0, -3]) pp.create_line(net, busnr3, busnr4, name="line2", length_km=0.50000, std_type="NAYY 4x50 SE") pp.create_load(net, busnr3, 0.030, 0.010, name="load1") pp.create_load(net, busnr4, 0.030, 0.010, name="load2") pp.create_sgen(net, busnr3, p_mw=0.020, q_mvar=0.005, name="pv1", sn_mva=0.03) pp.create_sgen(net, busnr4, p_mw=0.015, q_mvar=0.002, name="pv2", sn_mva=0.02) return net
def mixed_network(): net = pp.create_empty_network() pp.create_buses(net, nr_buses=5, vn_kv=20.) connections = [(0, 1), (1, 2), (2, 3), (2, 4)] for fb, tb in connections: pp.create_line(net, fb, tb, length_km=1, std_type="NA2XS2Y 1x185 RM/25 12/20 kV") for b in [1, 4, 3]: pp.create_ext_grid(net, b) return net
def big_sgen_three_bus_example(): net = pp.create_empty_network() b1 = pp.create_bus(net, 110) b2 = pp.create_bus(net, 110) b3 = pp.create_bus(net, 110) pp.create_ext_grid(net, b1, s_sc_max_mva=100., s_sc_min_mva=80., rx_min=0.4, rx_max=0.4) pp.create_line(net, b1, b2, std_type="305-AL1/39-ST1A 110.0" , length_km=20.) pp.create_line(net, b2, b3, std_type="N2XS(FL)2Y 1x185 RM/35 64/110 kV" , length_km=15.) net.line["endtemp_degree"] = 80 pp.create_sgen(net, b2, sn_mva=200., p_mw=0, k=1.2) return net
def ring_network(): net = pp.create_empty_network() b0 = pp.create_bus(net, 220) b1 = pp.create_bus(net, 110) b2 = pp.create_bus(net, 110) b3 = pp.create_bus(net, 110) pp.create_ext_grid(net, b0, s_sc_max_mva=100., s_sc_min_mva=80., rx_min=0.4, rx_max=0.4) pp.create_transformer(net, b0, b1, "100 MVA 220/110 kV") pp.create_line(net, b1, b2, std_type="305-AL1/39-ST1A 110.0" , length_km=20.) l2 = pp.create_line(net, b2, b3, std_type="N2XS(FL)2Y 1x185 RM/35 64/110 kV" , length_km=15.) pp.create_line(net, b3, b1, std_type="N2XS(FL)2Y 1x185 RM/35 64/110 kV" , length_km=10.) pp.create_switch(net, b3, l2, closed=False, et="l") return net
def test_graph_characteristics(feeder_network): # adapt network net = feeder_network bus0 = pp.create_bus(net, vn_kv=20.0) bus1 = pp.create_bus(net, vn_kv=20.0) bus2 = pp.create_bus(net, vn_kv=20.0) bus3 = pp.create_bus(net, vn_kv=20.0) bus4 = pp.create_bus(net, vn_kv=20.0) bus5 = pp.create_bus(net, vn_kv=20.0) bus6 = pp.create_bus(net, vn_kv=20.0) bus7 = pp.create_bus(net, vn_kv=20.0) bus8 = pp.create_bus(net, vn_kv=20.0) bus9 = pp.create_bus(net, vn_kv=20.0) new_connections = [(3, bus0), (bus0, bus1), (bus0, bus2), (1, bus3), (2, bus4), (bus3, bus4), (bus4, bus5), (bus4, bus6), (bus5, bus6), (2, bus7), (bus7, bus8), (bus8, bus9), (bus9, bus7)] for fb, tb in new_connections: pp.create_line(net, fb, tb, length_km=1.0, std_type="NA2XS2Y 1x185 RM/25 12/20 kV") # get characteristics mg = top.create_nxgraph(net, respect_switches=False) characteristics = [ "bridges", "articulation_points", "connected", "stub_buses", "required_bridges", "notn1_areas" ] char_dict = top.find_graph_characteristics(mg, net.ext_grid.bus, characteristics) bridges = char_dict["bridges"] articulation_points = char_dict["articulation_points"] connected = char_dict["connected"] stub_buses = char_dict["stub_buses"] required_bridges = char_dict["required_bridges"] notn1_areas = char_dict["notn1_areas"] assert bridges == {(3, 4), (4, 5), (4, 6), (2, 11)} assert articulation_points == {8, 3, 4, 2, 11} assert connected == {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13} assert stub_buses == {4, 5, 6, 11, 12, 13} assert required_bridges == { 4: [(3, 4)], 5: [(3, 4), (4, 5)], 6: [(3, 4), (4, 6)], 11: [(2, 11)], 12: [(2, 11)], 13: [(2, 11)] } assert notn1_areas == {8: {9, 10}, 3: {4, 5, 6}, 2: {11, 12, 13}}
def test_3ph_two_bus_line_powerfactory(): net = pp.create_empty_network() b1 = pp.create_bus(net, vn_kv=0.4) b2 = pp.create_bus(net, vn_kv=0.4) pp.create_ext_grid(net, b1, vm_pu=1.0, s_sc_max_mva=10, rx_max=0.1) net.ext_grid["x0x_max"] = 1. net.ext_grid["r0x0_max"] = 0.1 pp.create_std_type(net, {"r_ohm_per_km": 0.1013, "x_ohm_per_km": 0.06911504, "c_nf_per_km": 690, "g_us_per_km": 0, "max_i_ka": 0.44, "c0_nf_per_km": 312.4, "r0_ohm_per_km": 0.4053, "x0_ohm_per_km": 0.2764602}, "N2XRY 3x185sm 0.6/1kV") pp.create_line(net, b1, b2, 0.4, std_type="N2XRY 3x185sm 0.6/1kV") pp.add_zero_impedance_parameters(net) pp.create_load(net, b2, p_mw=0.010, q_mvar=0.010) pp.create_asymmetric_load(net, b2, p_a_mw=0.020, q_a_mvar=0.010, p_b_mw=0.015, q_b_mvar=0.005, p_c_mw=0.025, q_c_mvar=0.010) runpp_3ph_with_consistency_checks(net) assert net['converged'] bus_pp = np.abs(net.res_bus_3ph[['vm_a_pu', 'vm_b_pu', 'vm_c_pu']].values) bus_pf = np.abs(np.array([[0.99939853552, 1.0013885141, 0.99921580141], [0.97401782343, 0.98945593737, 0.96329605983]])) assert np.max(np.abs(bus_pp-bus_pf)) < 4e-6 line_pp = np.abs(net.res_line_3ph[ ['i_a_from_ka', 'i_b_from_ka', 'i_c_from_ka', 'i_a_to_ka', 'i_b_to_ka', 'i_c_to_ka', 'p_a_from_mw', 'p_b_from_mw', 'p_c_from_mw', 'q_a_from_mvar', 'q_b_from_mvar', 'q_c_from_mvar', 'p_a_to_mw', 'p_b_to_mw', 'p_c_to_mw', 'q_a_to_mvar', 'q_b_to_mvar', 'q_c_to_mvar']].values) line_pf = np.abs(np.array( [[0.11946088987 , 0.08812337783 , 0.14074226065 , 0.1194708224 , 0.088131567331 , 0.14075063601 , 0.023810539354 , 0.01855791658 , 0.029375192747 , 0.013901720672 , 0.008421814704 , 0.013852398586 , -0.023333142958 , -0.018333405987 , -0.028331643666 , -0.013332756527 , -0.008333413919 , -0.013332422725 ]])) assert np.max(np.abs(line_pp - line_pf)) < 1e-5 line_load_pp = np.abs(net.res_line_3ph[ ['loading_a_percent', 'loading_b_percent', 'loading_c_percent', 'loading_percent']].values) line_load_pf = np.abs(np.array( [[27.1525 , 20.0299 , 31.98878 , 31.98878]])) assert np.max(np.abs(line_load_pp - line_load_pf)) < 1e-2
def test_close_to_gen_simple(): # from pandapower.shortcircuit import calc_sc # vars = {name: getattr(calc_sc, name) for name in # dir(calc_sc) if not name.startswith('__')} # globals().update(vars) # del vars, calc_sc # WIP net = pp.create_empty_network() b1, b2, b3, b4, b5 = pp.create_buses(net, 5, 20) # skss = np.sqrt(3) * 400 * 40 # we assume 40 kA sc current in the 400-kV EHV grid # pp.create_ext_grid(net, b1, s_sc_max_mva=skss, s_sc_min_mva=0.8 * skss, rx_min=0.2, rx_max=0.4) pp.create_gen(net, b3, vn_kv=20, xdss_pu=0.2, rdss_pu=0.2 * 0.07, cos_phi=0.8, p_mw=5, sn_mva=5) pp.create_gen(net, b5, vn_kv=20, xdss_pu=0.2, rdss_pu=0.2 * 0.07, cos_phi=0.8, p_mw=10, sn_mva=10) pp.create_line(net, b1, b2, std_type="305-AL1/39-ST1A 110.0", length_km=10) pp.create_line(net, b2, b3, std_type="305-AL1/39-ST1A 110.0", length_km=10) pp.create_line(net, b3, b4, std_type="305-AL1/39-ST1A 110.0", length_km=50) pp.create_line(net, b4, b5, std_type="305-AL1/39-ST1A 110.0", length_km=10) # sc.calc_single_sc(net, b5) sc.calc_sc(net, tk_s=5e-2)
def panda_four_load_branch(): """ This function creates a simple six bus system with four radial low voltage nodes connected to \ a medium valtage slack bus. At every low voltage node the same load is connected. OUTPUT: **net** - Returns the required four load system EXAMPLE: import pandapower.networks as pn net_four_load = pn.panda_four_load_branch() """ pd_net = pp.create_empty_network() busnr1 = pp.create_bus(pd_net, name="bus1", vn_kv=10.) busnr2 = pp.create_bus(pd_net, name="bus2", vn_kv=.4) busnr3 = pp.create_bus(pd_net, name="bus3", vn_kv=.4) busnr4 = pp.create_bus(pd_net, name="bus4", vn_kv=.4) busnr5 = pp.create_bus(pd_net, name="bus5", vn_kv=.4) busnr6 = pp.create_bus(pd_net, name="bus6", vn_kv=.4) pp.create_ext_grid(pd_net, busnr1) pp.create_transformer(pd_net, busnr1, busnr2, std_type="0.25 MVA 10/0.4 kV") pp.create_line(pd_net, busnr2, busnr3, name="line1", length_km=0.05, std_type="NAYY 4x120 SE") pp.create_line(pd_net, busnr3, busnr4, name="line2", length_km=0.05, std_type="NAYY 4x120 SE") pp.create_line(pd_net, busnr4, busnr5, name="line3", length_km=0.05, std_type="NAYY 4x120 SE") pp.create_line(pd_net, busnr5, busnr6, name="line4", length_km=0.05, std_type="NAYY 4x120 SE") pp.create_load(pd_net, busnr3, 30, 10) pp.create_load(pd_net, busnr4, 30, 10) pp.create_load(pd_net, busnr5, 30, 10) pp.create_load(pd_net, busnr6, 30, 10) return pd_net
def _net_for_testing(): net = pp.create_empty_network() pp.create_buses(net, 17, 10, name=["Bus %i" % i for i in range(17)]) pp.create_buses(net, 2, 0.4, name=["Bus %i" % i for i in range(17, 19)]) pp.create_switch(net, 0, 1, "b", closed=True) pp.create_switch(net, 2, 3, "b", closed=False) pp.create_switch(net, 4, 5, "b", closed=False) pp.create_switch(net, 5, 6, "b", closed=True) pp.create_line(net, 7, 8, 1, 'NAYY 4x50 SE', name="Line 0") pp.create_switch(net, 7, 0, "l", closed=True) pp.create_switch(net, 8, 0, "l", closed=True) pp.create_line(net, 9, 10, 1, 'NAYY 4x50 SE', name="Line 1") pp.create_switch(net, 9, 1, "l", closed=False) pp.create_switch(net, 10, 1, "l", closed=True) pp.create_line(net, 11, 12, 1, 'NAYY 4x50 SE', name="Line 2") pp.create_switch(net, 11, 2, "l", closed=True) pp.create_switch(net, 12, 2, "l", closed=False) pp.create_line(net, 13, 14, 1, 'NAYY 4x50 SE', name="Line 3") pp.create_switch(net, 13, 3, "l", closed=False) pp.create_switch(net, 14, 3, "l", closed=False) pp.create_transformer(net, 15, 17, std_type="0.4 MVA 10/0.4 kV", name="Trafo 0") pp.create_switch(net, 15, 0, "t", closed=True) pp.create_switch(net, 17, 0, "t", closed=False) pp.create_transformer(net, 16, 18, std_type="0.4 MVA 10/0.4 kV", name="Trafo 1") pp.create_switch(net, 16, 1, "t", closed=False) pp.create_switch(net, 18, 1, "t", closed=True) return net
def tnep_grid(): net = pp.create_empty_network() min_vm_pu = 0.95 max_vm_pu = 1.05 # create buses bus1 = pp.create_bus(net, vn_kv=110., geodata=(5, 9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus2 = pp.create_bus(net, vn_kv=110., geodata=(6, 10), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus3 = pp.create_bus(net, vn_kv=110., geodata=(10, 9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus4 = pp.create_bus(net, vn_kv=110., geodata=(8, 8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) # create 110 kV lines pp.create_line(net, bus1, bus2, length_km=70., std_type='149-AL1/24-ST1A 110.0') pp.create_line(net, bus1, bus3, length_km=50., std_type='149-AL1/24-ST1A 110.0') pp.create_line(net, bus1, bus4, length_km=100., std_type='149-AL1/24-ST1A 110.0') # create loads pp.create_load(net, bus2, p_mw=60) pp.create_load(net, bus3, p_mw=70) pp.create_load(net, bus4, p_mw=50) # create generators g1 = pp.create_gen(net, bus1, p_mw=9.513270, min_p_mw=0, max_p_mw=200, vm_pu=1.01, slack=True) pp.create_poly_cost(net, g1, 'gen', cp1_eur_per_mw=1) g2 = pp.create_gen(net, bus2, p_mw=78.403291, min_p_mw=0, max_p_mw=200, vm_pu=1.01) pp.create_poly_cost(net, g2, 'gen', cp1_eur_per_mw=3) g3 = pp.create_gen(net, bus3, p_mw=92.375601, min_p_mw=0, max_p_mw=200, vm_pu=1.01) pp.create_poly_cost(net, g3, 'gen', cp1_eur_per_mw=3) net.line["max_loading_percent"] = 20 # possible new lines (set out of service in line DataFrame) l1 = pp.create_line(net, bus1, bus4, 10., std_type="305-AL1/39-ST1A 110.0", name="new_line1", max_loading_percent=20., in_service=False) l2 = pp.create_line(net, bus2, bus4, 20., std_type="149-AL1/24-ST1A 110.0", name="new_line2", max_loading_percent=20., in_service=False) l3 = pp.create_line(net, bus3, bus4, 30., std_type='149-AL1/24-ST1A 110.0', name="new_line3", max_loading_percent=20., in_service=False) l4 = pp.create_line(net, bus3, bus4, 40., std_type='149-AL1/24-ST1A 110.0', name="new_line4", max_loading_percent=20., in_service=False) new_line_index = [l1, l2, l3, l4] construction_costs = [10., 20., 30., 45.] # create new line dataframe init_ne_line(net, new_line_index, construction_costs) return net
def __init__(self): # create empty net net = pp.create_empty_network() # create buses b1 = pp.create_bus(net, vn_kv=20., name="Bus 1") b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2") b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3") # create bus elements pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection") pp.create_load(net, bus=b3, p_mw=0.1, q_mvar=0.05, name="Load") # create branch elements tid = pp.create_transformer(net, hv_bus=b1, lv_bus=b2, std_type="0.4 MVA 20/0.4 kV", name="Trafo") pp.create_line(net, from_bus=b2, to_bus=b3, length_km=0.1, name="Line", std_type="NAYY 4x50 SE") self.pp_network: pp.pandapowerNet = net
def test_bus_bus_switch_at_eg(): net = pp.create_empty_network() b1 = pp.create_bus(net, name="bus1", vn_kv=.4) b2 = pp.create_bus(net, name="bus2", vn_kv=.4) b3 = pp.create_bus(net, name="bus3", vn_kv=.4) pp.create_ext_grid(net, b1) pp.create_switch(net, b1, et="b", element=1) pp.create_line(net, b2, b3, 1, name="line1", std_type="NAYY 4x150 SE") pp.create_load(net, b3, p_kw=10, q_kvar=0, name="load1") runpp_with_consistency_checks(net)
def meshed_network(): net = pp.create_empty_network("7bus_system") # ext grid b = [] b.append(pp.create_bus(net, vn_kv=380., name="exi", geodata=(0, 0))) pp.create_ext_grid(net, b[0], name="exi") # create 110kV buses for i in range(1, 7): b.append( pp.create_bus(net, vn_kv=110., name="bus" + str(i), geodata=(0, 0))) # connect buses b1 to b6 with overhead lines for i in range(1, 6): l = pp.create_line(net, b[i], b[i + 1], length_km=10. * i * 2., std_type="149-AL1/24-ST1A 110.0", name="line" + str(i), index=i + 2) pp.create_switch(net, b[i], l, et="l", name="bl_switch_" + str(i), index=i + 3) # create trafo pp.create_transformer(net, hv_bus=b[0], lv_bus=b[1], std_type="160 MVA 380/110 kV", name="trafo") # create some more lines between b6-b1 and b1-b4 pp.create_line(net, b[1], b[4], length_km=100., std_type="149-AL1/24-ST1A 110.0", name="line6") pp.create_line(net, b[6], b[1], length_km=100., std_type="149-AL1/24-ST1A 110.0", name="line7") return net
def test_create_replacement_switch_for_branch(): 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) pp.create_ext_grid(net, bus0, vm_pu=0.4) line0 = pp.create_line(net, bus0, bus1, length_km=1, std_type="NAYY 4x50 SE") line1 = pp.create_line(net, bus2, bus3, length_km=1, std_type="NAYY 4x50 SE") impedance0 = pp.create_impedance(net, bus1, bus2, 0.01, 0.01, sn_kva=1e5) impedance1 = pp.create_impedance(net, bus1, bus2, 0.01, 0.01, sn_kva=1e5) pp.create_load(net, bus2, 1) pp.runpp(net) # look that the switch is created properly tb.create_replacement_switch_for_branch(net, 'line', line0) tb.create_replacement_switch_for_branch(net, 'impedance', impedance0) net.line.in_service.at[line0] = False net.impedance.in_service.at[impedance0] = False assert 'REPLACEMENT_line_0' in net.switch.name.values assert 'REPLACEMENT_impedance_0' in net.switch.name.values assert net.switch.closed.at[0] assert net.switch.closed.at[1] pp.runpp(net) # look that the switch is created with the correct closed status net.line.in_service.at[line1] = False net.impedance.in_service.at[impedance1] = False tb.create_replacement_switch_for_branch(net, 'line', line1) tb.create_replacement_switch_for_branch(net, 'impedance', impedance1) assert 'REPLACEMENT_line_1' in net.switch.name.values assert 'REPLACEMENT_impedance_1' in net.switch.name.values assert ~net.switch.closed.at[2] assert ~net.switch.closed.at[3]
def add_aclines(network, df=None, file=None): """ Add AC-lines to the specified network. Pass either a DataFrame or a pathstring to a csv-file. Parameters ---------- network : pandapowerNet PandaPower network representation. df : DataFrame DataFrame with bus characteristics. file : str Path to csv-file with AC-line characteristics. Return ------ net : pandapowerNet PandaPower network representation with added AC-lines. """ # copy network net = copy.deepcopy(network) # load AC lines linesAC = check_arguments(df, file) # create dictonairy of busnames and busindices busdict = dict(zip(net.bus.name, net.bus.index)) # parameter lines parameter_lines = linesAC[linesAC.std_type.isna() == True] for index, line in parameter_lines.iterrows(): pp.create_line_from_parameters(net, name=line['name'], from_bus=busdict[line.from_bus], to_bus=busdict[line.to_bus], length_km=line.length_km, r_ohm_per_km=line.r_ohm_per_km, x_ohm_per_km=line.x_ohm_per_km, c_nf_per_km=line.c_nf_per_km, max_i_ka=line.max_i_ka, parallel=line.parallel, type=line.type, in_service=line.in_service, max_loading_percent=line.max_loading_percent) # default lines default_lines = linesAC[linesAC.std_type.isna() == False] for index, line in default_lines.iterrows(): pp.create_line(net, name=line['name'], from_bus=busdict[line.from_bus], to_bus=busdict[line.to_bus], length_km=line.length_km, std_type=line.std_type, parallel=line.parallel, in_service=line.in_service, max_loading_percent=line.max_loading_percent) return net
def ring_network(): net = pp.create_empty_network() b1 = pp.create_bus(net, 220) b2 = pp.create_bus(net, 110) b3 = pp.create_bus(net, 110) b4 = pp.create_bus(net, 110) pp.create_ext_grid(net, b1, s_sc_max_mva=100., s_sc_min_mva=80., rx_min=0.20, rx_max=0.35) pp.create_transformer(net, b1, b2, "100 MVA 220/110 kV") pp.create_line(net, b2, b3, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV", length_km=15.) l2 = pp.create_line(net, b3, b4, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV", length_km=12.) pp.create_line(net, b4, b2, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV", length_km=10.) pp.create_switch(net, b4, l2, closed=False, et="l") return net
def test_bsfw_algorithm_with_branch_loops(): net = example_simple() pp.create_line(net, 0, 6, length_km=2.5, std_type="NA2XS2Y 1x240 RM/25 12/20 kV", name="Line meshed") net.switch.loc[:, "closed"] = True pp.runpp(net) vm_nr = net.res_bus.vm_pu va_nr = net.res_bus.va_degree pp.runpp(net, algorithm='bfsw') vm_alg = net.res_bus.vm_pu va_alg = net.res_bus.va_degree assert np.allclose(vm_nr, vm_alg) assert np.allclose(va_nr, va_alg)
def test_create_line_alpha_temperature(): net = pp.create_empty_network() b = pp.create_buses(net, 5, 110) l1 = pp.create_line(net, 0, 1, 10, "48-AL1/8-ST1A 10.0") l2 = pp.create_line(net, 1, 2, 10, "48-AL1/8-ST1A 10.0", alpha=4.03e-3, temperature_degree_celsius=80) l3 = pp.create_line(net, 2, 3, 10, "48-AL1/8-ST1A 10.0") l4 = pp.create_line_from_parameters(net, 3, 4, 10, 1, 1, 1, 100) l5 = pp.create_line_from_parameters(net, 3, 4, 10, 1, 1, 1, 100, alpha=4.03e-3) assert 'alpha' in net.line.columns assert all(net.line.loc[[l2, l3, l5], 'alpha'] == 4.03e-3) assert all(net.line.loc[[l1, l4], 'alpha'].isnull()) assert net.line.loc[l2, 'temperature_degree_celsius'] == 80 assert all(net.line.loc[[l1, l3, l4, l5], 'temperature_degree_celsius'].isnull())
def test_0gen_2ext_grid_decoupled(): net = create_test_network2() net.gen = net.gen.drop(0) net.shunt.q_kvar *= -1 pp.create_ext_grid(net, 1) net.ext_grid.in_service.at[1] = False pp.create_ext_grid(net, 3) net.ext_grid.in_service.at[2] = False auxbus = pp.create_bus(net, name="bus1", vn_kv=10.) net.trafo.shift_degree = 150 pp.create_std_type(net, { "type": "cs", "r_ohm_per_km": 0.876, "q_mm2": 35.0, "endtmp_deg": 160.0, "c_nf_per_km": 260.0, "max_i_ka": 0.123, "x_ohm_per_km": 0.1159876 }, name="NAYSEY 3x35rm/16 6/10kV", element="line") pp.create_line( net, 0, auxbus, 1, name="line_to_decoupled_grid", std_type="NAYSEY 3x35rm/16 6/10kV") #NAYSEY 3x35rm/16 6/10kV pp.create_ext_grid(net, auxbus) pp.create_switch(net, auxbus, 2, et="l", closed=0, type="LS") pp.runpp(net, init='dc', calculate_voltage_angles=True) assert np.allclose( net.res_bus.p_kw.values, [-133.158732, 30.000000, 0.000000, 100.000000, 0.000000]) assert np.allclose( net.res_bus.q_kvar.values, [39.5843982697, 2.000000, -28.5636406913, 0.000000, 0.000000]) assert np.allclose( net.res_bus.va_degree.values, [0.000000, -155.752225311, -153.669395244, -0.0225931152895, 0.0]) assert np.allclose(net.res_bus.vm_pu.values, [1.000000, 0.930961, 0.975764, 0.998865, 1.0]) assert np.allclose(net.res_ext_grid.p_kw.values, [-133.158732, 0.000000, 0.000000, -0.000000]) assert np.allclose(net.res_ext_grid.q_kvar, [39.5843982697, 0.000000, 0.000000, -0.000000])
def simple_test_net(): net = pp.create_empty_network() pp.set_user_pf_options(net, init='dc', calculate_voltage_angles=True) b0 = pp.create_bus(net, 110) b1 = pp.create_bus(net, 110) b2 = pp.create_bus(net, 20) b3 = pp.create_bus(net, 20) b4 = pp.create_bus(net, 6) pp.create_ext_grid(net, b0) pp.create_line(net, b0, b1, 10, "149-AL1/24-ST1A 110.0") pp.create_transformer(net, b1, b2, "25 MVA 110/20 kV", name='tr1') pp.create_transformer3w_from_parameters(net, b1, b3, b4, 110, 20, 6, 1e2, 1e2, 1e1, 3, 2, 2, 1, 1, 1, 100, 1, 60, 30, 'hv', tap_step_percent=1.5, tap_step_degree=0, tap_pos=0, tap_neutral=0, tap_max=10, tap_min=-10, name='tr2') pp.create_load(net, b2, 1.5e1, 1, name='trafo1') pp.create_load(net, b3, 3e1, 1.5, name='trafo2_mv') pp.create_load(net, b4, 2, -0.15, name='trafo2_lv') return net
def test_check_existing_measurements(): np.random.seed(2017) net = pp.create_empty_network() pp.create_bus(net, 10.) pp.create_bus(net, 10.) pp.create_line(net, 0, 1, 0.5, std_type="149-AL1/24-ST1A 10.0") m1 = pp.create_measurement(net, "v", "bus", 1.006, .004, 0) m2 = pp.create_measurement(net, "v", "bus", 1.006, .004, 0) assert m1 == m2 assert len(net.measurement) == 1 m3 = pp.create_measurement(net, "v", "bus", 1.006, .004, 0, check_existing=False) assert m3 != m2 assert len(net.measurement) == 2 m4 = pp.create_measurement(net, "p", "line", -0.0011e3, 0.01e3, bus=0, element=0, check_existing=True) m5 = pp.create_measurement(net, "p", "line", -0.0011e3, 0.01e3, bus=0, element=0, check_existing=True) assert m4 == m5 m6 = pp.create_measurement(net, "p", "line", -0.0011e3, 0.01e3, bus=0, element=0, check_existing=False) assert m5 != m6
def test_pandapower_case(): #more complicated examples like #net = pandapower.networks.example_simple() #can be used once the import of e.g. switches is perfected #create empty net net = pp.create_empty_network() #create buses b1 = pp.create_bus(net, vn_kv=20., name="Bus 1") b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2") b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3") #create bus elements pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection") pp.create_load(net, bus=b3, p_kw=100, q_kvar=50, name="Load") #create branch elements tid = pp.create_transformer(net, hv_bus=b1, lv_bus=b2, std_type="0.4 MVA 20/0.4 kV", name="Trafo") pp.create_line(net, from_bus=b2, to_bus=b3, length_km=0.1, name="Line", std_type="NAYY 4x50 SE") #because of phase angles, need to init with DC pp.runpp(net,calculate_voltage_angles=True,init="dc") n = pypsa.Network() n.import_from_pandapower_net(net) #seed PF with LPF solution because of phase angle jumps n.lpf() n.pf(use_seed=True) #use same index for everything net.res_bus.index = net.bus.name.values net.res_line.index = net.line.name.values #compare bus angles np.testing.assert_array_almost_equal(n.buses_t.v_ang.loc["now"]*180/np.pi,net.res_bus.va_degree) #compare bus voltage magnitudes np.testing.assert_array_almost_equal(n.buses_t.v_mag_pu.loc["now"],net.res_bus.vm_pu) #compare bus active power (NB: pandapower uses load signs) np.testing.assert_array_almost_equal(n.buses_t.p.loc["now"],-net.res_bus.p_kw/1e3) #compare bus active power (NB: pandapower uses load signs) np.testing.assert_array_almost_equal(n.buses_t.q.loc["now"],-net.res_bus.q_kvar/1e3) #compare branch flows np.testing.assert_array_almost_equal(n.lines_t.p0.loc["now"],net.res_line.p_from_kw/1e3) np.testing.assert_array_almost_equal(n.lines_t.p1.loc["now"],net.res_line.p_to_kw/1e3) np.testing.assert_array_almost_equal(n.lines_t.q0.loc["now"],net.res_line.q_from_kvar/1e3) np.testing.assert_array_almost_equal(n.lines_t.q1.loc["now"],net.res_line.q_to_kvar/1e3) np.testing.assert_array_almost_equal(n.transformers_t.p0.loc["now"],net.res_trafo.p_hv_kw/1e3) np.testing.assert_array_almost_equal(n.transformers_t.p1.loc["now"],net.res_trafo.p_lv_kw/1e3) np.testing.assert_array_almost_equal(n.transformers_t.q0.loc["now"],net.res_trafo.q_hv_kvar/1e3) np.testing.assert_array_almost_equal(n.transformers_t.q1.loc["now"],net.res_trafo.q_lv_kvar/1e3)