def test_drop_inactive_elements(): net = pp.create_empty_network() service = 0 bus0 = pp.create_bus(net, vn_kv=.4, in_service=service) pp.create_ext_grid(net, bus0, in_service=service) bus1 = pp.create_bus(net, vn_kv=.4, in_service=service) pp.create_transformer(net, bus0, bus1, in_service=service, std_type= '63 MVA 110/20 kV') bus2 = pp.create_bus(net, vn_kv=.4, in_service=service) pp.create_line(net, bus1, bus2, length_km=1, in_service=service, std_type='149-AL1/24-ST1A 10.0') pp.create_load(net, bus2, p_kw=0., in_service=service) pp.create_sgen(net, bus2, p_kw=0., in_service=service) # drop them tb.drop_inactive_elements(net) sum_of_elements = 0 for element in net.keys(): # skip this one since we expect items here if element == "std_types": continue try: sum_of_elements += len(net[element]) except TypeError: # _ppc is initialized with None and clashes when checking continue assert sum_of_elements == 0
def 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, x0x_max=0.2, x0x_min=0.1, r0x0_max=0.3, r0x0_min=0.2) net.ext_grid['x0x_min'] = 0.1 net.ext_grid['r0x0_min'] = 0.1 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['r0_ohm_per_km'] = 0.1 net.line['x0_ohm_per_km'] = 0.1 net.line['c0_nf_per_km'] = 0.1 net.line["endtemp_degree"] = 80 pp.create_sgen(net, b2, sn_mva=2, p_mw=0, k=1.2) return net
def test_contingency_sgen(base_net): net = base_net pp.create_sgen(net, 1, p_kw=-100, q_kvar=0, controllable=True, max_p_kw=-5, min_p_kw=-150, max_q_kvar=50, min_q_kvar=-50) # pwl costs # maximize the sgen feed in by using a positive cost slope # using a slope of 1 # | / # | / # | / # |/ #------------------------------------------- # p_min_kw /| # / | # / | pp.create_piecewise_linear_cost( net, 0, "sgen", array([[net.sgen.min_p_kw.at[0], net.sgen.min_p_kw.at[0]], [0, 0]])) pp.runopp(net) assert abs(net.res_cost - net.res_sgen.p_kw.at[0]) < 1e-5 # minimize the sgen feed in by using a positive cost slope # using a slope of 1 # \ | # \ | # \ | # \| #------------------------------------------- # p_min_kw |\ # | \ # | \ net.piecewise_linear_cost.f.at[0] *= -1 pp.runopp(net) assert abs(net.res_cost - net.res_sgen.p_kw.at[0] * -1) < 1e-5 try: net.piecewise_linear_cost = net.piecewise_linear_cost.drop(index=0) except: net.piecewise_linear_cost = net.piecewise_linear_cost.drop(0) # first using a positive slope as in the case above pp.create_polynomial_cost(net, 0, "sgen", array([1, 0])) pp.runopp(net) assert abs(net.res_cost - net.res_sgen.p_kw.at[0]) < 1e-5 # negative slope as in the case above net.polynomial_cost.c.at[0] *= -1 pp.runopp(net) assert abs(net.res_cost - net.res_sgen.p_kw.at[0] * -1) < 1e-5
def test_wye_delta(): from pandapower.pypower.idx_brch import BR_R, BR_X, BR_B net = pp.create_empty_network() pp.create_bus(net, vn_kv=110) pp.create_buses(net, nr_buses=4, vn_kv=20) trafo = pp.create_transformer(net, hv_bus=0, lv_bus=1, std_type='25 MVA 110/20 kV') pp.create_line(net, 1, 2, length_km=2.0, std_type="NAYY 4x50 SE") pp.create_line(net, 2, 3, length_km=6.0, std_type="NAYY 4x50 SE") pp.create_line(net, 3, 4, length_km=10.0, std_type="NAYY 4x50 SE") pp.create_ext_grid(net, 0) pp.create_load(net, 4, p_mw=0.1) pp.create_sgen(net, 2, p_mw=4.) pp.create_sgen(net, 3, p_mw=4.) pp.runpp(net, trafo_model="pi") f, t = net._pd2ppc_lookups["branch"]["trafo"] assert np.isclose(net.res_trafo.p_hv_mw.at[trafo], -7.560996, rtol=1e-7) assert np.allclose(net._ppc["branch"][f:t, [BR_R, BR_X, BR_B]].flatten(), np.array([0.0001640 + 0.j, 0.0047972 + 0.j, -0.0105000 - 0.014j]), rtol=1e-7) pp.runpp(net, trafo_model="t") assert np.allclose(net._ppc["branch"][f:t, [BR_R, BR_X, BR_B]].flatten(), np.array([0.00016392 + 0.j, 0.00479726 + 0.j, -0.01050009 - 0.01399964j])) assert np.isclose(net.res_trafo.p_hv_mw.at[trafo], -7.561001, rtol=1e-7)
def 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 test_cost_pol_q(): """ Testing a very simple network for the resulting cost value constraints with OPF """ # boundaries: vm_max = 1.05 vm_min = 0.95 # create net net = pp.create_empty_network() pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.) pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4) pp.create_sgen(net, 1, p_mw=0.1, controllable=True, min_p_mw=0.005, max_p_mw=0.15, max_q_mvar=0.05, min_q_mvar=-0.05) pp.create_ext_grid(net, 0) pp.create_load(net, 1, p_mw=0.02, controllable=False) pp.create_line_from_parameters(net, 0, 1, 50, name="line2", r_ohm_per_km=0.876, c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876, max_loading_percent=100 * 690) pp.create_poly_cost(net, 0, "sgen", cp1_eur_per_mw=0, cq1_eur_per_mvar=-1) # run OPF pp.runopp(net) assert net["OPF_converged"] assert abs(net.res_cost + (net.res_sgen.q_mvar.values)) < 1e-2 net.poly_cost.cq1_eur_per_mvar.at[0] = 0 net.poly_cost.cq2_eur_per_mvar2.at[0] = 1 # net.poly_cost.c.at[0] = np.array([[1, 0, 0]]) # run OPF pp.runopp(net) assert net["OPF_converged"] assert np.isclose(net.res_cost, net.res_sgen.q_mvar.values**2)
def test_cost_piecewise_linear_sgen_uneven_slopes(): """ 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_sgen(net, 1, p_kw=-100, controllable=True, max_p_kw=-5, min_p_kw=-150, max_q_kvar=50, min_q_kvar=-50) pp.create_ext_grid(net, 0) pp.create_load(net, 1, p_kw=20, controllable=False) pp.create_line_from_parameters(net, 0, 1, 50, name="line2", r_ohm_per_km=0.876, c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876, max_loading_percent=100 * 690) pp.create_piecewise_linear_cost(net, 0, "sgen", np.array([[-150, 200], [-75, 50], [0, 0]])) # run OPF pp.runopp(net, verbose=False) assert net["OPF_converged"] assert net.res_cost - net.res_sgen.p_kw.values / 1.5 < 1e-3
def three_bus_big_sgen_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 add_test_bus_bus_switch(net): b1, b2, ln = add_grid_connection(net, zone="test_bus_bus_switch") b3 = pp.create_bus(net, vn_kv=20., zone="test_bus_bus_switch") pp.create_switch(net, b2, b3, et="b") pl = 1000 ql = 500 psg = -500 qsg = 100 pz = 1200 qz = 1100 ps = 500 qs = 200 vm_pu = 1.06 r_ohm = 50 x_ohm = 70 pp.create_load(net, b2, p_kw=pl, q_kvar=ql) pp.create_load(net, b3, p_kw=pl, q_kvar=ql, scaling=0.5) pp.create_sgen(net, b2, p_kw=psg, q_kvar=qsg) pp.create_sgen(net, b3, p_kw=psg, q_kvar=qsg, scaling=0.5) pp.create_ward(net, b2, pz_kw=pz, qz_kvar=qz, ps_kw=ps, qs_kvar=qs) pp.create_ward(net, b3, pz_kw=0.5 * pz, qz_kvar=0.5 * qz, ps_kw=0.5 * ps, qs_kvar=0.5 * qs) pp.create_xward(net, b3, 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_xward(net, b2, pz_kw=pz, qz_kvar=qz, ps_kw=ps, qs_kvar=qs, vm_pu=vm_pu, x_ohm=x_ohm, r_ohm=r_ohm) net.last_added_case = "test_bus_bus_switch" return net
def test_cost_piecewise_linear_sgen_very_unsteady_slopes(): """ Testing a very simple network for the resulting cost value constraints with OPF """ # boundaries: vm_max = 1.5 vm_min = 0.5 # 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_sgen(net, 1, p_mw=0.10, controllable=True, min_p_mw=0, max_p_mw=1.50, max_q_mvar=0.05, min_q_mvar=-0.05) pp.create_ext_grid(net, 0) pp.create_load(net, 1, p_mw=0.02, controllable=False) pp.create_line_from_parameters(net, 0, 1, 50, name="line2", r_ohm_per_km=0.876, c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876, max_loading_percent=100 * 690) pp.create_pwl_cost(net, 0, "sgen", [[0, 0.75, -1], [0.75, 1500, 2]]) # run OPF pp.runopp(net) assert net["OPF_converged"] assert np.isclose(net.res_sgen.p_mw.values[0], .75, rtol=1e-2) assert np.isclose(net.res_sgen.p_mw.values[0], -net.res_cost, rtol=1e-2)
def test_balanced_power_flow_with_unbalanced_loads_and_sgens(): net = pp.create_empty_network(sn_mva=100) make_nw(net, 10, 0, "wye", "Dyn") pp.create_asymmetric_sgen(net, 1, p_a_mw=0.01, p_b_mw=0.02, scaling=0.8) runpp_with_consistency_checks(net) vm_pu = net.res_bus.vm_pu net.asymmetric_load.in_service = False pp.create_load( net, bus=net.asymmetric_load.bus.iloc[0], scaling=net.asymmetric_load.scaling.iloc[0], p_mw=net.asymmetric_load.loc[0, ["p_a_mw", "p_b_mw", "p_c_mw"]].sum(), q_mvar=net.asymmetric_load.loc[ 0, ["q_a_mvar", "q_b_mvar", "q_c_mvar"]].sum()) runpp_with_consistency_checks(net) assert net.res_bus.vm_pu.equals(vm_pu) net.asymmetric_sgen.in_service = False pp.create_sgen( net, bus=net.asymmetric_sgen.bus.iloc[0], scaling=net.asymmetric_sgen.scaling.iloc[0], p_mw=net.asymmetric_sgen.loc[0, ["p_a_mw", "p_b_mw", "p_c_mw"]].sum(), q_mvar=net.asymmetric_sgen.loc[ 0, ["q_a_mvar", "q_b_mvar", "q_c_mvar"]].sum()) runpp_with_consistency_checks(net) assert net.res_bus.vm_pu.equals(vm_pu)
def test_cost_pol_q(): """ Testing a very simple network for the resulting cost value constraints with OPF """ # boundaries: vm_max = 1.05 vm_min = 0.95 # create net net = pp.create_empty_network() pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.) pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4) pp.create_sgen(net, 1, p_kw=-100, controllable=True, max_p_kw=-5, min_p_kw=-150, max_q_kvar=50, min_q_kvar=-50) pp.create_ext_grid(net, 0) pp.create_load(net, 1, p_kw=20, controllable=False) pp.create_line_from_parameters(net, 0, 1, 50, name="line2", r_ohm_per_km=0.876, c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876, max_loading_percent=100 * 690) pp.create_polynomial_cost(net, 0, "sgen", np.array([0, -1, 0]), type="q") # run OPF pp.runopp(net, verbose=False) assert net["OPF_converged"] assert abs(net.res_cost + (net.res_sgen.q_kvar.values)) < 1e-2 net.polynomial_cost.c.at[0] = np.array([[1, 0, 0]]) # run OPF pp.runopp(net, verbose=False) assert net["OPF_converged"] assert abs(net.res_cost - net.res_sgen.q_kvar.values**2) < 1e-5
def net(): net = networks.create_kerber_vorstadtnetz_kabel_1() for i, load in net.load.iterrows(): pp.create_sgen(net, load.bus, p_mw=1 * 1e-3, sn_mva=2 * 1e-3) return net
def simple_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)) b3 = pp.create_bus(net, name="bus3", geodata=(1, 3)) b4 = pp.create_bus(net, name="bus4", vn_kv=10.) pp.create_transformer(net, b4, b2, std_type="0.25 MVA 10/0.4 kV", name=None, in_service=True, index=None) pp.create_line(net, b2, b3, 1, name="line1", std_type="NAYY 4x150 SE", geodata=np.array([[1, 2], [3, 4]])) pp.create_line(net, b1, b4, 1, name="line2", std_type="NAYY 4x150 SE") pp.create_load(net, b2, p_mw=0.01, q_mvar=0, name="load1") pp.create_load(net, b3, p_mw=0.04, q_mvar=0.002, name="load2") pp.create_gen(net, 3, q_mvar=0.020, vm_pu=1.0) pp.create_sgen(net, 2, p_mw=0.050, sn_mva=0.1) return net
def test_cost_piecewise_linear_sgen(): """ 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_sgen(net, 1, p_mw=-0.1, controllable=True, max_p_mw=-0.005, min_p_mw=-0.15, max_q_mvar=0.05, min_q_mvar=-0.05) pp.create_ext_grid(net, 0) pp.create_load(net, 1, p_mw=0.02, controllable=False) pp.create_line_from_parameters(net, 0, 1, 50, name="line2", r_ohm_per_km=0.876, c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876, max_loading_percent=100 * 690) pp.create_pwl_cost(net, 0, "sgen", [[-150, -75, 1.5], [-75, 0, -1.5]]) # run OPF pp.runopp(net, ) assert net["OPF_converged"] assert net.res_cost - net.res_sgen.p_mw.values / 1.5 < 1e-3
def test_connectivity_check_island_without_pv_bus(): # Network with islands without pv bus -> all buses in island should be set out of service net = create_cigre_network_mv(with_der=False) iso_buses, iso_p, iso_q = get_isolated(net) assert len(iso_buses) == 0 assert np.isclose(iso_p, 0) assert np.isclose(iso_q, 0) isolated_bus1 = pp.create_bus(net, vn_kv=20., name="isolated Bus1") isolated_bus2 = pp.create_bus(net, vn_kv=20., name="isolated Bus2") pp.create_line(net, isolated_bus2, isolated_bus1, length_km=1, std_type="N2XS(FL)2Y 1x300 RM/35 64/110 kV", name="IsolatedLine") iso_buses, iso_p, iso_q = get_isolated(net) assert len(iso_buses) == 2 assert np.isclose(iso_p, 0) assert np.isclose(iso_q, 0) pp.create_load(net, isolated_bus1, p_kw=200., q_kvar=20) pp.create_sgen(net, isolated_bus2, p_kw=-150., q_kvar=-10) # with pytest.warns(UserWarning): iso_buses, iso_p, iso_q = get_isolated(net) assert len(iso_buses) == 2 assert np.isclose(iso_p, 350) assert np.isclose(iso_q, 30) # with pytest.warns(UserWarning): runpp_with_consistency_checks(net, check_connectivity=True)
def create_test_network(): """Creates a simple pandapower test network """ net = pp.create_empty_network() b1 = pp.create_bus(net, name="bus1", vn_kv=10.) pp.create_ext_grid(net, b1) b2 = pp.create_bus(net, name="bus2", geodata=(1, 2), vn_kv=.4) b3 = pp.create_bus(net, name="bus3", geodata=(1, 3), vn_kv=.4, index=7) b4 = pp.create_bus(net, name="bus4", vn_kv=10.) pp.create_transformer_from_parameters(net, b4, b2, vk_percent=3.75, tap_max=2, vn_lv_kv=0.4, shift_degree=150, tap_neutral=0, vn_hv_kv=10.0, vkr_percent=2.8125, tap_pos=0, tap_side="hv", tap_min=-2, tap_step_percent=2.5, i0_percent=0.68751, sn_mva=0.016, pfe_kw=0.11, name=None, in_service=True, index=None) # 0.016 MVA 10/0.4 kV ET 16/23 SGB pp.create_line_from_parameters(net, b2, b3, 1, name="line1", r_ohm_per_km=0.2067, ices=0.389985, c_nf_per_km=720.0, max_i_ka=0.328, x_ohm_per_km=0.1897522, geodata=np.array([[1, 2], [3, 4]])) # NAYY 1x150RM 0.6/1kV ir pp.create_line_from_parameters(net, b1, b4, 1, name="line2", r_ohm_per_km=0.876, c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876) # NAYSEY 3x35rm/16 6/10kV pp.create_load(net, b2, p_mw=0.010, q_mvar=0, name="load1") pp.create_load(net, b3, p_mw=0.040, q_mvar=0.002, name="load2") pp.create_gen(net, b4, p_mw=0.200, vm_pu=1.0) pp.create_sgen(net, b3, p_mw=0.050, sn_mva=0.1) return net
def test_pmu_with_trafo3w(): net = pp.create_empty_network() bus_slack = pp.create_bus(net, vn_kv=110) pp.create_ext_grid(net, bus=bus_slack) bus_20_1 = pp.create_bus(net, vn_kv=20, name="b") pp.create_sgen(net, bus=bus_20_1, p_mw=0.03, q_mvar=0.02) bus_10_1 = pp.create_bus(net, vn_kv=10) pp.create_sgen(net, bus=bus_10_1, p_mw=0.02, q_mvar=0.02) bus_10_2 = pp.create_bus(net, vn_kv=10) pp.create_load(net, bus=bus_10_2, p_mw=0.06, q_mvar=0.01) pp.create_line(net, from_bus=bus_10_1, to_bus=bus_10_2, std_type="149-AL1/24-ST1A 10.0", length_km=2) pp.create_transformer3w(net, bus_slack, bus_20_1, bus_10_1, std_type="63/25/38 MVA 110/20/10 kV") pp.runpp(net) add_virtual_pmu_meas_from_loadflow(net, with_random_error=False) run_se_lp_verify(net)
def simple_four_bus_system(): """ This function creates a simple four bus system with two radial low voltage nodes connected to \ a medium valtage slack bus. At both low voltage nodes the a load and a static generator is \ connected. RETURN: **net** - Returns the required four bus system EXAMPLE: import pandapower.networks as pn net_simple_four_bus = pn.simple_four_bus_system() """ net = pp.create_empty_network() busnr1 = pp.create_bus(net, name="bus1ref", vn_kv=10) pp.create_ext_grid(net, busnr1) busnr2 = pp.create_bus(net, name="bus2", vn_kv=.4) pp.create_transformer(net, busnr1, busnr2, name="transformer", std_type="0.25 MVA 10/0.4 kV") busnr3 = pp.create_bus(net, name="bus3", vn_kv=.4) pp.create_line(net, busnr2, busnr3, name="line1", length_km=0.50000, std_type="NAYY 4x50 SE") busnr4 = pp.create_bus(net, name="bus4", vn_kv=.4) pp.create_line(net, busnr3, busnr4, name="line2", length_km=0.50000, std_type="NAYY 4x50 SE") pp.create_load(net, busnr3, 30, 10, name="load1") pp.create_load(net, busnr4, 30, 10, name="load2") pp.create_sgen(net, busnr3, p_kw=-20., q_kvar=-5., name="pv1", sn_kva=30) pp.create_sgen(net, busnr4, p_kw=-15., q_kvar=-2., name="pv2", sn_kva=20) return net
def motor_net(): 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, s_sc_max_mva=10., rx_max=0.1) pp.create_line_from_parameters(net, from_bus=b1, to_bus=b2, length_km=1., r_ohm_per_km=0.3211, x_ohm_per_km=0.06911504, c_nf_per_km=0, max_i_ka=1) pp.create_sgen(net, b2, p_kw=110, sn_kva=500, type="motor", k=7, rx=0.6) return net
def _change_ref_bus(net, ref_bus_idx, ext_grid_p=0): """ This function changes the current reference bus / buses, declared by net.ext_grid.bus towards \ the given 'ref_bus_idx' If ext_grid_p is a list, it must be in the same order as net.ext_grid.index. """ # cast ref_bus_idx and ext_grid_p as list if not isinstance(ref_bus_idx, list): ref_bus_idx = [ref_bus_idx] if not isinstance(ext_grid_p, list): ext_grid_p = [ext_grid_p] for i in ref_bus_idx: if i not in net.gen.bus.values and i not in net.ext_grid.bus.values: raise ValueError( "Index %i is not in net.gen.bus or net.ext_grid.bus." % i) # determine indeces of ext_grid and gen connected to ref_bus_idx gen_idx = net.gen.loc[net.gen.bus.isin(ref_bus_idx)].index ext_grid_idx = net.ext_grid.loc[~net.ext_grid.bus.isin(ref_bus_idx)].index # old ext_grid -> gen j = 0 for i in ext_grid_idx: ext_grid_data = net.ext_grid.loc[i] net.ext_grid.drop(i, inplace=True) pp.create_gen(net, ext_grid_data.bus, ext_grid_p[j], vm_pu=ext_grid_data.vm_pu, controllable=True, min_q_kvar=ext_grid_data.min_q_kvar, max_q_kvar=ext_grid_data.max_q_kvar, min_p_kw=ext_grid_data.min_p_kw, max_p_kw=ext_grid_data.max_p_kw) j += 1 # store gen data gen_data = net.gen.loc[gen_idx] net.gen.drop(net.gen.index[gen_idx], inplace=True) # old gen at ref_bus -> ext_grid (and sgen) for i in gen_idx: gen_i_data = gen_data.loc[i] if gen_i_data.bus not in net.ext_grid.bus.values: pp.create_ext_grid(net, gen_i_data.bus, vm_pu=gen_i_data.vm_pu, va_degree=0., min_q_kvar=gen_i_data.min_q_kvar, max_q_kvar=gen_i_data.max_q_kvar, min_p_kw=gen_i_data.min_p_kw, max_p_kw=gen_i_data.max_p_kw) else: pp.create_sgen(net, gen_i_data.bus, p_kw=gen_i_data.p_kw, min_q_kvar=gen_i_data.min_q_kvar, max_q_kvar=gen_i_data.max_q_kvar, min_p_kw=gen_i_data.min_p_kw, max_p_kw=gen_i_data.max_p_kw)
def test_drop_inactive_elements(): for service in (False, True): net = pp.create_empty_network() bus_sl = pp.create_bus(net, vn_kv=.4, in_service=service) pp.create_ext_grid(net, bus_sl, in_service=service) bus0 = pp.create_bus(net, vn_kv=.4, in_service=service) pp.create_switch(net, bus_sl, bus0, 'b', not service) bus1 = pp.create_bus(net, vn_kv=.4, in_service=service) pp.create_transformer(net, bus0, bus1, in_service=service, std_type='63 MVA 110/20 kV') bus2 = pp.create_bus(net, vn_kv=.4, in_service=service) pp.create_line(net, bus1, bus2, length_km=1, in_service=service, std_type='149-AL1/24-ST1A 10.0') pp.create_load(net, bus2, p_mw=0., in_service=service) pp.create_sgen(net, bus2, p_mw=0., in_service=service) bus3 = pp.create_bus(net, vn_kv=.4, in_service=service) bus4 = pp.create_bus(net, vn_kv=.4, in_service=service) pp.create_transformer3w_from_parameters(net, bus2, bus3, bus4, 0.4, 0.4, 0.4, 100, 50, 50, 3, 3, 3, 1, 1, 1, 5, 1) # drop them tb.drop_inactive_elements(net) sum_of_elements = 0 for element, table in net.items(): # skip this one since we expect items here if element.startswith("_") or not isinstance(table, pd.DataFrame): continue try: if service and (element == 'ext_grid' or (element == 'bus' and len(net.bus) == 1)): # if service==True, the 1 ext_grid and its bus are not dropped continue if len(table) > 0: sum_of_elements += len(table) print(element) except TypeError: # _ppc is initialized with None and clashes when checking continue assert sum_of_elements == 0 if service: assert len(net.ext_grid) == 1 assert len(net.bus) == 1 assert bus_sl in net.bus.index.values net = pp.create_empty_network() bus0 = pp.create_bus(net, vn_kv=.4, in_service=True) pp.create_ext_grid(net, bus0, in_service=True) bus1 = pp.create_bus(net, vn_kv=.4, in_service=False) pp.create_line(net, bus0, bus1, length_km=1, in_service=False, std_type='149-AL1/24-ST1A 10.0') gen0 = pp.create_gen(net, bus=bus1, p_mw=0.001) tb.drop_inactive_elements(net) assert gen0 not in net.gen.index
def check_energy(self, user_send, load_indices): print(user_send) for id1, send in user_send.items(): violated, violation_type = self.violations(self._net) if violated: break else: bus_number = load_indices[id1] pp.create_sgen(self._net, bus_number, send / 1000, q_mvar=1) return (violated, violation_type)
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_scaling_by_type(): net = pp.create_empty_network() bus0 = pp.create_bus(net, 0.4) pp.create_load(net, bus0, p_kw=0., type="Household") pp.create_sgen(net, bus0, p_kw=0., type="PV") tb.set_scaling_by_type(net, {"Household": 42., "PV": 12}) assert net.load.at[0, "scaling"] == 42 assert net.sgen.at[0, "scaling"] == 12
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, vk_percent=3.75, tap_max=2, vn_lv_kv=0.4, shift_degree=150, tap_neutral=0, vn_hv_kv=10.0, vkr_percent=2.8125, tap_pos=0, tap_side="hv", tap_min=-2, tap_step_percent=2.5, i0_percent=0.68751, sn_mva=0.016, pfe_kw=0.11, name=None, in_service=True, index=None, max_loading_percent=max_trafo_loading) pp.create_sgen(net, 3, p_mw=0.1, controllable=True, min_p_mw=0.005, max_p_mw=0.15, max_q_mvar=0.025, min_q_mvar=-0.025) pp.create_sgen(net, 2, p_mw=0.1, controllable=True, min_p_mw=0.005, max_p_mw=0.15, max_q_mvar=0.025, min_q_mvar=-0.025) pp.create_poly_cost(net, 0, "sgen", cp1_eur_per_mw=10) pp.create_poly_cost(net, 1, "sgen", cp1_eur_per_mw=10) pp.create_ext_grid(net, 0) pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=.1) 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, init="flat") assert net["OPF_converged"] assert np.allclose(net["_ppc"]["branch"][:, 5], np.array([0.02771281+0.j, 0.00692820+0.j, 0.12800000+0.j])) # 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_contingency_sgen(base_net): net = base_net pp.create_sgen(net, 1, p_mw=0.1, q_mvar=0, controllable=True, min_p_mw=0.005, max_p_mw=0.150, max_q_mvar=0.05, min_q_mvar=-0.05) # pwl costs # maximize the sgen feed in by using a positive cost slope # using a slope of 1 # | / # | / # | / # |/ #------------------------------------------- # p_min_mw /| # / | # / | pwl = pp.create_pwl_cost(net, 0, "sgen", [[0, net.sgen.max_p_mw.at[0], 1]]) pp.runopp(net) assert isclose(net.res_cost, net.res_sgen.p_mw.at[0], atol=1e-3) # minimize the sgen feed in by using a positive cost slope # using a slope of 1 # \ | # \ | # \ | # \| #------------------------------------------- # p_min_mw |\ # | \ # | \ net.pwl_cost.points.loc[pwl] = [(0, net.sgen.max_p_mw.at[0], -1)] pp.runopp(net) assert isclose(net.res_cost, -net.res_sgen.p_mw.at[0], atol=1e-4) net.pwl_cost.drop(0, inplace=True) # first using a positive slope as in the case above pp.create_poly_cost(net, 0, "sgen", cp1_eur_per_mw=1.) pp.runopp(net) assert isclose(net.res_cost, net.res_sgen.p_mw.at[0], atol=1e-3) # negative slope as in the case above net.poly_cost.cp1_eur_per_mw.at[0] *= -1 pp.runopp(net) assert isclose(net.res_cost, -net.res_sgen.p_mw.at[0], atol=1e-4)
def add_test_load_sgen_split(net): b1, b2, ln = add_grid_connection(net, zone="test_load_sgen_split") nr = 2 pl = 1.2 ql = 1.1 ps = 0.5 qs = -0.1 for _ in list(range(nr)): pp.create_load(net, b2, p_mw=pl, q_mvar=ql, scaling=1. / nr) pp.create_sgen(net, b2, p_mw=ps, q_mvar=qs, scaling=1. / nr) net.last_added_case = "test_load_sgen_split" return net
def test_3point_pwl(): 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_sgen(net, 1, p_mw=0.1, q_mvar=0, controllable=True, min_p_mw=0.1, max_p_mw=0.15, max_q_mvar=0.05, min_q_mvar=-0.05) pp.create_ext_grid(net, 0) pp.create_load(net, 1, p_mw=0.02, controllable=False) pp.create_line_from_parameters(net, 0, 1, 50, name="line2", r_ohm_per_km=0.876, c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876, max_loading_percent=100 * 690) # creating a pwl cost function that actually is realistic: The absolute value of the reactive power has costs. pp.create_pwl_cost(net, 0, "sgen", [[-50, 0, -1.5], [0, 50, 1.5]], power_type="q") pp.runopp(net) # The reactive power should be at zero to minimze the costs. assert np.isclose(net.res_sgen.q_mvar.values, 0, atol=1e-4) assert np.isclose(net.res_cost, abs(net.res_sgen.q_mvar.values) * 1.5, atol=1e-4) #TODO costs seem to be assigned to ext_grid, not to sgen (net.res_ext_grid.q_mvar*1.5=net.res_cost) # They are however correctly assigned in the gencost array, this seems to be a bug in PYPOWER net.sgen.min_q_mvar = 0.05 net.sgen.max_q_mvar = 0.1 pp.runopp(net) assert np.isclose(net.res_sgen.q_mvar.values, 0.05, atol=1e-4) assert np.isclose(net.res_cost, abs(net.res_sgen.q_mvar.values) * 1.5, atol=1e-4)
def add_test_load_sgen_split(net): b1, b2, ln = add_grid_connection(net, zone="test_load_sgen_split") nr = 2 pl = 1200 ql = 1100 ps = -500 qs = 100 for _ in list(range(nr)): pp.create_load(net, b2, p_kw=pl, q_kvar=ql, scaling=1. / nr) pp.create_sgen(net, b2, p_kw=ps, q_kvar=qs, scaling=1. / nr) net.last_added_case = "test_load_sgen_split" return net