def test_dcline_dispatch2(dcline_net): net = dcline_net pp.create_polynomial_cost(net, 0, "ext_grid", array([.08, 0])) pp.create_polynomial_cost(net, 1, "ext_grid", array([.1, 0])) net.bus["max_vm_pu"] = 2 net.bus["min_vm_pu"] = 0 # needs to be constrained more than default net.line[ "max_loading_percent"] = 1000 # does not converge if unconstrained pp.runopp(net) consistency_checks(net, rtol=1e-3) consistency_checks(net, rtol=1e-3) rel_loss_expect = (net.res_dcline.pl_kw - net.dcline.loss_kw) / \ (net.res_dcline.p_from_kw - net.res_dcline.pl_kw) * 100 assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values) p_eg_expect = array([-8.21525358e+05, -5.43498903e-02]) q_eg_expect = array([7787.55852923, 21048.59213887]) assert allclose(net.res_ext_grid.p_kw.values, p_eg_expect) assert allclose(net.res_ext_grid.q_kvar.values, q_eg_expect) p_from_expect = array([813573.88366999]) q_from_expect = array([-26446.0473644]) assert allclose(net.res_dcline.p_from_kw.values, p_from_expect) assert allclose(net.res_dcline.q_from_kvar.values, q_from_expect) p_to_expect = array([-805023.64719801]) q_to_expect = array([-21736.31196315]) assert allclose(net.res_dcline.p_to_kw.values, p_to_expect) assert allclose(net.res_dcline.q_to_kvar.values, q_to_expect)
def test_dispatch1(dcline_net): net = dcline_net pp.create_pwl_cost(net, 0, "ext_grid", [[-1e12, 1e9, 100]]) pp.create_pwl_cost(net, 1, "ext_grid", [[-1e12, 1e9, 80]]) net.bus["max_vm_pu"] = 2 net.bus["min_vm_pu"] = 0 # needs to be constrained more than default net.line[ "max_loading_percent"] = 1000 # does not converge if unconstrained pp.runopp(net, delta=1e-8) consistency_checks(net) rel_loss_expect = (net.res_dcline.pl_mw - net.dcline.loss_mw) / \ (net.res_dcline.p_from_mw - net.res_dcline.pl_mw) * 100 assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values, rtol=1e-2) assert allclose(net.res_ext_grid.p_mw.values, [0.5, 805], atol=0.1) assert allclose(net.res_ext_grid.q_mvar.values, [-7.78755773243, 0.62830727889], atol=1e-3) assert allclose(net.res_dcline.p_from_mw.values, [0.500754071], atol=1e-3) assert allclose(net.res_dcline.q_from_mvar.values, [7.78745600524]) assert allclose(net.res_dcline.p_to_mw.values, array([-5.48553789e-05])) assert allclose(net.res_dcline.q_to_mvar.values, array([-.62712636707]))
def test_dispatch1(dcline_net): net = dcline_net pp.create_piecewise_linear_cost( net, 0, "ext_grid", array([[-1e12, -0.1 * 1e12], [1e12, .1 * 1e12]])) pp.create_piecewise_linear_cost( net, 1, "ext_grid", array([[-1e12, -0.08 * 1e12], [1e12, .08 * 1e12]])) net.bus["max_vm_pu"] = 2 net.bus["min_vm_pu"] = 0 # needs to be constrained more than default net.line[ "max_loading_percent"] = 1000 # does not converge if unconstrained pp.runopp(net) consistency_checks(net, rtol=1e-3) rel_loss_expect = (net.res_dcline.pl_kw - net.dcline.loss_kw) / \ (net.res_dcline.p_from_kw - net.res_dcline.pl_kw) * 100 assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values) p_eg_expect = array([-5.00078353e+02, -8.05091476e+05]) q_eg_expect = array([7787.55773243, -628.30727889]) assert allclose(net.res_ext_grid.p_kw.values, p_eg_expect) assert allclose(net.res_ext_grid.q_kvar.values, q_eg_expect) p_from_expect = array([500.0754071]) q_from_expect = array([7787.45600524]) assert allclose(net.res_dcline.p_from_kw.values, p_from_expect) assert allclose(net.res_dcline.q_from_kvar.values, q_from_expect) p_to_expect = array([-0.0746605]) q_to_expect = array([-627.12636707]) assert allclose(net.res_dcline.p_to_kw.values, p_to_expect) assert allclose(net.res_dcline.q_to_kvar.values, q_to_expect)
def test_dcline_dispatch2(dcline_net): net = dcline_net pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=80) pp.create_poly_cost(net, 1, "ext_grid", cp1_eur_per_mw=100) # pp.create_poly_cost(net, 0, "ext_grid", array([.08, 0])) # pp.create_poly_cost(net, 1, "ext_grid", array([.1, 0])) net.bus["max_vm_pu"] = 2 net.bus["min_vm_pu"] = 0 # needs to be constrained more than default net.line[ "max_loading_percent"] = 1000 # does not converge if unconstrained # pp.runopp(net, delta=get_delta_try_except(net)) pp.runopp(net) consistency_checks(net, rtol=1e-3) rel_loss_expect = (net.res_dcline.pl_mw - net.dcline.loss_mw) / \ (net.res_dcline.p_from_mw - net.res_dcline.pl_mw) * 100 assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values) p_eg_expect = array([8.21525358e+02, 5.43498903e-05]) q_eg_expect = array([-7787.55852923e-3, -21048.59213887e-3]) assert allclose(net.res_ext_grid.p_mw.values, p_eg_expect) assert allclose(net.res_ext_grid.q_mvar.values, q_eg_expect) p_from_expect = array([813573.88366999e-3]) q_from_expect = array([-26446.0473644e-3]) assert allclose(net.res_dcline.p_from_mw.values, p_from_expect) assert allclose(net.res_dcline.q_from_mvar.values, q_from_expect) p_to_expect = array([-805023.64719801e-3]) q_to_expect = array([-21736.31196315e-3]) assert allclose(net.res_dcline.p_to_mw.values, p_to_expect) assert allclose(net.res_dcline.q_to_mvar.values, q_to_expect)
def test_dcline_dispatch3(dcline_net): net = dcline_net pp.create_polynomial_cost(net, 0, "dcline", array([1, 0])) net.bus["max_vm_pu"] = 2 # needs to be constrained more than default net.line[ "max_loading_percent"] = 1000 # does not converge if unconstrained pp.runopp(net) consistency_checks(net, rtol=1e-3) consistency_checks(net, rtol=1e-3) rel_loss_expect = (net.res_dcline.pl_kw - net.dcline.loss_kw) / \ (net.res_dcline.p_from_kw - net.res_dcline.pl_kw) * 100 assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values) assert abs(net.res_dcline.p_from_kw.values - net.res_cost) < 1e-3
def test_pwl(): net = pp.create_empty_network() # create buses bus1 = pp.create_bus(net, vn_kv=110., min_vm_pu=0.9, max_vm_pu=1.1) bus2 = pp.create_bus(net, vn_kv=110., min_vm_pu=0.9, max_vm_pu=1.1) bus3 = pp.create_bus(net, vn_kv=110., min_vm_pu=0.9, max_vm_pu=1.1) # create 110 kV lines pp.create_line(net, bus1, bus2, length_km=50., std_type='149-AL1/24-ST1A 110.0') pp.create_line(net, bus2, bus3, length_km=50., std_type='149-AL1/24-ST1A 110.0') # create loads pp.create_load(net, bus2, p_mw=80, controllable=False) # create generators g1 = pp.create_gen(net, bus1, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01, slack=True) g2 = pp.create_gen(net, bus3, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01) # net.gen["controllable"] = False pp.create_pwl_cost(net, g1, 'gen', [[0, 2, 2], [2, 80, 5]]) pp.create_pwl_cost(net, g2, 'gen', [[0, 2, 2], [2, 80, 5]]) pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.iloc[0], net.res_gen.p_mw.iloc[1]) assert np.isclose(net.res_gen.q_mvar.iloc[0], net.res_gen.q_mvar.iloc[1]) net.pwl_cost.drop(net.pwl_cost.index, inplace=True) g3 = pp.create_gen(net, bus1, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01) pp.create_pwl_cost(net, g1, 'gen', [[0, 2, 1.], [2, 80, 8.]]) pp.create_pwl_cost(net, g2, 'gen', [[0, 3, 2.], [3, 80, 14]]) pp.create_pwl_cost(net, g3, 'gen', [[0, 1, 3.], [1, 80, 10.]]) net.load.p_mw = 1 pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.at[g2], 0) assert np.isclose(net.res_gen.p_mw.at[g3], 0) assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1], atol=1e-4) net.load.p_mw = 3 pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.at[g3], 0) assert np.isclose(net.res_gen.p_mw.at[g1], 2) assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] + net.res_gen.p_mw.at[g2] * 2, atol=1e-4) net.load.p_mw = 5 pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.at[g1], 2) assert np.isclose(net.res_gen.p_mw.at[g2], 3) assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] + net.res_gen.p_mw.at[g2] * 2 + net.res_gen.p_mw.at[g3] * 3, atol=1e-4)
def test_voltage_angles(): net = pp.create_empty_network() b1, b2, l1 = add_grid_connection(net, vn_kv=110.) b3 = pp.create_bus(net, vn_kv=20.) b4 = pp.create_bus(net, vn_kv=10.) b5 = pp.create_bus(net, vn_kv=10., in_service=False) tidx = pp.create_transformer3w(net, b2, b3, b4, std_type='63/25/38 MVA 110/20/10 kV', max_loading_percent=120) pp.create_load(net, b3, p_mw=5, controllable=False) load_id = pp.create_load(net, b4, p_mw=5, controllable=True, max_p_mw=50, min_p_mw=0, min_q_mvar=-1e6, max_q_mvar=1e6) pp.create_poly_cost(net, load_id, "load", cp1_eur_per_mw=-1000) net.trafo3w.shift_lv_degree.at[tidx] = 120 net.trafo3w.shift_mv_degree.at[tidx] = 80 custom_file = os.path.join( os.path.abspath(os.path.dirname(pp.test.__file__)), "test_files", "run_powermodels_custom.jl") # TODO: pp.runpm_dc gives does not seem to consider the voltage angles. Is this intended behaviour? for run in [pp.runpm_ac_opf, partial(pp.runpm, julia_file=custom_file)]: run(net) consistency_checks(net) print(net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b3]) print(net.res_bus.va_degree.at[b1]) print(net.res_bus.va_degree.at[b3]) assert 119.9 < net.res_trafo3w.loading_percent.at[tidx] <= 120 assert 85 < (net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b3]) % 360 < 86 assert 120 < (net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b4]) % 360 < 130 assert np.isnan(net.res_bus.va_degree.at[b5])
def test_compare_pwl_and_poly(net_3w_trafo_opf): net = net_3w_trafo_opf pp.create_pwl_cost(net, 0, 'ext_grid', [[0, 1, 1]]) pp.create_pwl_cost(net, 0, 'gen', [[0, 30, 3], [30, 80, 3]]) pp.create_pwl_cost(net, 1, 'gen', [[0, 100, 2]]) pp.runpm_ac_opf(net) consistency_checks(net) p_gen = net.res_gen.p_mw.values q_gen = net.res_gen.q_mvar.values vm_bus = net.res_bus.vm_pu.values va_bus = net.res_bus.va_degree.values net.pwl_cost.drop(net.pwl_cost.index, inplace=True) pp.create_poly_cost(net, 0, 'ext_grid', cp1_eur_per_mw=1) pp.create_poly_cost(net, 0, 'gen', cp1_eur_per_mw=3) pp.create_poly_cost(net, 1, 'gen', cp1_eur_per_mw=2) pp.runpm_ac_opf(net) consistency_checks(net) np.allclose(p_gen, net.res_gen.p_mw.values) np.allclose(q_gen, net.res_gen.q_mvar.values) np.allclose(vm_bus, net.res_bus.vm_pu.values) np.allclose(va_bus, net.res_bus.va_degree.values) pp.runpm_dc_opf(net) consistency_checks(net) np.allclose(p_gen, net.res_gen.p_mw.values) np.allclose(va_bus, net.res_bus.va_degree.values)
def test_dcline_dispatch3(dcline_net): net = dcline_net pp.create_poly_cost(net, 4, "dcline", cp1_eur_per_mw=1.5) net.bus["max_vm_pu"] = 1.03 # needs to be constrained more than default net.line[ "max_loading_percent"] = 1000 # does not converge if unconstrained pp.runopp(net) consistency_checks(net, rtol=1e-1) # dc line is not dispatched because of the assigned costs assert isclose(net.res_dcline.at[4, "p_to_mw"], 0, atol=1e-2) assert all(net.res_ext_grid.p_mw.values > 0) # costs for ext_grid at the end of the DC line get double the costs of DC line transfer pp.create_poly_cost(net, 1, "ext_grid", cp1_eur_per_mw=2000) pp.runopp(net) #now the total power is supplied through the DC line assert (net.res_dcline.at[4, "p_to_mw"]) < 1e3 assert net.res_ext_grid.p_mw.at[1] < 1 assert isclose(net.res_cost, net.res_dcline.at[4, "p_from_mw"] * 1.5)
def test_voltage_angles(): net = pp.create_empty_network() b1, b2, l1 = add_grid_connection(net, vn_kv=110.) b3 = pp.create_bus(net, vn_kv=20.) b4 = pp.create_bus(net, vn_kv=10.) b5 = pp.create_bus(net, vn_kv=10., in_service=False) tidx = pp.create_transformer3w( net, b2, b3, b4, std_type='63/25/38 MVA 110/20/10 kV', max_loading_percent=120) pp.create_load(net, b3, p_mw=5, controllable=False) load_id = pp.create_load(net, b4, p_mw=5, controllable=True, max_p_mw=25, min_p_mw=0, min_q_mvar=-1e-6, max_q_mvar=1e-6) pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=1) pp.create_poly_cost(net, load_id, "load", cp1_eur_per_mw=1000) net.trafo3w.shift_lv_degree.at[tidx] = 10 net.trafo3w.shift_mv_degree.at[tidx] = 30 net.bus.loc[:, "max_vm_pu"] = 1.1 net.bus.loc[:, "min_vm_pu"] = .9 custom_file = os.path.join(os.path.abspath(os.path.dirname(pp.test.__file__)), "test_files", "run_powermodels_custom.jl") # load is zero since costs are high. PF results should be the same as OPF net.load.loc[1, "p_mw"] = 0. pp.runpp(net, calculate_voltage_angles=True) va_degree = net.res_bus.loc[:, "va_degree"].values vm_pu = net.res_bus.loc[:, "vm_pu"].values loading3w = net.res_trafo3w.loc[:, "loading_percent"].values for run in [pp.runpm_ac_opf, partial(pp.runpm, julia_file=custom_file)]: run(net, calculate_voltage_angles=True) consistency_checks(net) assert 30. < (net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b3]) % 360 < 32. assert 10. < (net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b4]) % 360 < 11. assert np.isnan(net.res_bus.va_degree.at[b5]) assert np.allclose(net.res_bus.va_degree.values, va_degree, atol=1e-6, rtol=1e-6, equal_nan=True) assert np.allclose(net.res_bus.vm_pu.values, vm_pu, atol=1e-6, rtol=1e-6, equal_nan=True) assert np.allclose(net.res_trafo3w.loading_percent, loading3w, atol=1e-2, rtol=1e-2, equal_nan=True)
def test_compare_pwl_and_poly(net_3w_trafo_opf): net = net_3w_trafo_opf net.ext_grid.loc[:, "min_p_mw"] = -999. net.ext_grid.loc[:, "max_p_mw"] = 999. net.ext_grid.loc[:, "max_q_mvar"] = 999. net.ext_grid.loc[:, "min_q_mvar"] = -999. pp.create_pwl_cost(net, 0, 'ext_grid', [[0, 1, 1]]) pp.create_pwl_cost(net, 0, 'gen', [[0, 30, 3], [30, 80, 3]]) pp.create_pwl_cost(net, 1, 'gen', [[0, 80, 2]]) net.bus.loc[:, "max_vm_pu"] = 1.1 net.bus.loc[:, "min_vm_pu"] = .9 pp.runpm_ac_opf(net) consistency_checks(net) p_gen = net.res_gen.p_mw.values q_gen = net.res_gen.q_mvar.values vm_bus = net.res_bus.vm_pu.values va_bus = net.res_bus.va_degree.values net.pwl_cost.drop(net.pwl_cost.index, inplace=True) pp.create_poly_cost(net, 0, 'ext_grid', cp1_eur_per_mw=1) pp.create_poly_cost(net, 0, 'gen', cp1_eur_per_mw=3) pp.create_poly_cost(net, 1, 'gen', cp1_eur_per_mw=2) # pp.runopp(net) pp.runpm_ac_opf(net, correct_pm_network_data=False) consistency_checks(net) np.allclose(p_gen, net.res_gen.p_mw.values) np.allclose(q_gen, net.res_gen.q_mvar.values) np.allclose(vm_bus, net.res_bus.vm_pu.values) np.allclose(va_bus, net.res_bus.va_degree.values) # pp.rundcopp(net) pp.runpm_dc_opf(net, correct_pm_network_data=False) consistency_checks(net, test_q=False) np.allclose(p_gen, net.res_gen.p_mw.values) np.allclose(va_bus, net.res_bus.va_degree.values)
#create loads pp.create_load(net, bus2, p_kw=60e3, controllable=False) pp.create_load(net, bus3, p_kw=70e3, controllable=False) pp.create_load(net, bus4, p_kw=10e3, controllable=False) #create generators eg = pp.create_ext_grid(net, bus1, min_p_kw=-1e9, max_p_kw=1e9) g0 = pp.create_gen(net, bus3, p_kw=-80 * 1e3, min_p_kw=-80e3, max_p_kw=0, vm_pu=1.01, controllable=True) g1 = pp.create_gen(net, bus4, p_kw=-100 * 1e3, min_p_kw=-100e3, max_p_kw=0, vm_pu=1.01, controllable=True) costeg = pp.create_polynomial_cost(net, 0, 'ext_grid', np.array([-1, 0])) costgen1 = pp.create_polynomial_cost(net, 0, 'gen', np.array([-1, 0])) costgen2 = pp.create_polynomial_cost(net, 1, 'gen', np.array([-1, 0])) runpm(net) if net.OPF_converged: from pandapower.test.consistency_checks import consistency_checks consistency_checks(net)
def test_without_ext_grid(): net = pp.create_empty_network() min_vm_pu = 0.95 max_vm_pu = 1.05 # create buses bus1 = pp.create_bus(net, vn_kv=220., geodata=(5, 9)) bus2 = pp.create_bus(net, vn_kv=110., geodata=(6, 10), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus3 = pp.create_bus(net, vn_kv=110., geodata=(10, 9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus4 = pp.create_bus(net, vn_kv=110., geodata=(8, 8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus5 = pp.create_bus(net, vn_kv=110., geodata=(6, 8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) # create 220/110/110 kV 3W-transformer pp.create_transformer3w_from_parameters(net, bus1, bus2, bus5, vn_hv_kv=220, vn_mv_kv=110, vn_lv_kv=110, vk_hv_percent=10., vk_mv_percent=10., vk_lv_percent=10., vkr_hv_percent=0.5, vkr_mv_percent=0.5, vkr_lv_percent=0.5, pfe_kw=100, i0_percent=0.1, shift_mv_degree=0, shift_lv_degree=0, sn_hv_mva=100, sn_mv_mva=50, sn_lv_mva=50) # create 110 kV lines pp.create_line(net, bus2, bus3, length_km=70., std_type='149-AL1/24-ST1A 110.0') pp.create_line(net, bus3, bus4, length_km=50., std_type='149-AL1/24-ST1A 110.0') pp.create_line(net, bus4, bus2, length_km=40., std_type='149-AL1/24-ST1A 110.0') pp.create_line(net, bus4, bus5, length_km=30., std_type='149-AL1/24-ST1A 110.0') # create loads pp.create_load(net, bus2, p_mw=60, controllable=False) pp.create_load(net, bus3, p_mw=70, controllable=False) pp.create_load(net, bus4, p_mw=10, controllable=False) # create generators g1 = pp.create_gen(net, bus1, p_mw=40, min_p_mw=0, min_q_mvar=-20, max_q_mvar=20, slack=True, min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) pp.create_poly_cost(net, g1, 'gen', cp1_eur_per_mw=1000) g2 = pp.create_gen(net, bus3, p_mw=40, min_p_mw=0, min_q_mvar=-20, max_q_mvar=20, vm_pu=1.01, min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu, max_p_mw=40.) pp.create_poly_cost(net, g2, 'gen', cp1_eur_per_mw=2000) g3 = pp.create_gen(net, bus4, p_mw=0.050, min_p_mw=0, min_q_mvar=-20, max_q_mvar=20, vm_pu=1.01, min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu, max_p_mw=0.05) pp.create_poly_cost(net, g3, 'gen', cp1_eur_per_mw=3000) pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.at[g2], 0, atol=1e-5, rtol=1e-5) assert np.isclose(net.res_gen.p_mw.at[g3], 0, atol=1e-5, rtol=1e-5) assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] * 1e3) net.trafo3w["max_loading_percent"] = 150. pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert 149. < net.res_trafo3w.loading_percent.values[0] < 150.01 assert np.isclose( net.res_cost, net.res_gen.p_mw.at[g1] * 1e3 + net.res_gen.p_mw.at[g2] * 2e3) pp.runpm_dc_opf(net) consistency_checks(net, rtol=1e-3, test_q=False) assert 149. < net.res_trafo3w.loading_percent.values[0] < 150.01 assert np.isclose( net.res_cost, net.res_gen.p_mw.at[g1] * 1e3 + net.res_gen.p_mw.at[g2] * 2e3)