def test_create_realistic(): net = pn.example_multivoltage() pp.runpp(net) all_vn_kv = pd.Series([380, 110, 20, 10, 0.4]) assert net.bus.vn_kv.isin(all_vn_kv).all() assert len(net.bus) >= 1 assert len(net.line) >= 1 assert len(net.gen) >= 1 assert len(net.sgen) >= 1 assert len(net.shunt) >= 1 assert len(net.trafo) >= 1 assert len(net.trafo3w) >= 1 assert len(net.load) >= 1 assert len(net.ext_grid) >= 1 assert len(net.switch[net.switch.et == 'l']) >= 1 assert len(net.switch[net.switch.et == 'b']) >= 1 assert len(net.switch[net.switch.et == 't']) >= 1 assert len(net.switch[net.switch.type == 'CB']) >= 1 assert len(net.switch[net.switch.type == 'DS']) >= 1 assert len(net.switch[net.switch.type == 'LBS']) >= 1 assert len(net.switch[net.switch.closed]) >= 1 assert len(net.switch[~net.switch.closed]) >= 1 assert len(net.impedance) >= 1 assert len(net.xward) >= 1 assert net.converged
def test_continuous_element_numbering(): from pandapower.estimation.util import add_virtual_meas_from_loadflow net = nw.example_multivoltage() # Add noises to index with some large number net.line.rename(index={4: 280}, inplace=True) net.trafo.rename(index={0: 300}, inplace=True) net.trafo.rename(index={1: 400}, inplace=True) net.trafo3w.rename(index={0: 540}, inplace=True) net.switch.loc[(net.switch.et == "l") & (net.switch.element == 4), "element"] = 280 net.switch.loc[(net.switch.et == "t") & (net.switch.element == 0), "element"] = 300 net.switch.loc[(net.switch.et == "t") & (net.switch.element == 1), "element"] = 400 pp.runpp(net) add_virtual_meas_from_loadflow(net) assert net.measurement["element"].max() == 540 net = tb.create_continuous_elements_index(net) assert net.line.index.max() == net.line.shape[0] - 1 assert net.trafo.index.max() == net.trafo.shape[0] - 1 assert net.trafo3w.index.max() == net.trafo3w.shape[0] - 1 assert net.measurement["element"].max() == net.bus.shape[0] - 1
def test_merge_parallel_line(): net = nw.example_multivoltage() pp.runpp(net) assert net.line.parallel.at[5] == 2 line = net.line.loc[5] fbus = line.from_bus tbus = line.to_bus fbus_0 = net.res_bus.loc[fbus] tbus_0 = net.res_bus.loc[tbus] ploss_0 = (net.res_line.loc[5].p_from_mw - net.res_line.loc[5].p_to_mw) qloss_0 = (net.res_line.loc[5].q_from_mvar - net.res_line.loc[5].q_to_mvar) net = tb.merge_parallel_line(net,5) assert net.line.parallel.at[5] == 1 pp.runpp(net) fbus_1 = net.res_bus.loc[fbus] tbus_1 = net.res_bus.loc[tbus] ploss_1 = (net.res_line.loc[5].p_from_mw - net.res_line.loc[5].p_to_mw) qloss_1 = (net.res_line.loc[5].q_from_mvar - net.res_line.loc[5].q_to_mvar) assert_series_equal(fbus_0, fbus_1) assert_series_equal(tbus_0, tbus_1) assert np.isclose(ploss_0, ploss_1, atol=1e-5) assert np.isclose(qloss_0, qloss_1)
def test_get_element_indices(): net = nw.example_multivoltage() idx1 = pp.get_element_indices(net, "bus", ["Bus HV%i" % i for i in range(1, 4)]) idx2 = pp.get_element_indices(net, ["bus", "line"], "HV", exact_match=False) idx3 = pp.get_element_indices(net, ["bus", "line"], ["Bus HV3", "MV Line6"]) assert [32, 33, 34] == idx1 assert ([32, 33, 34, 35] == idx2[0]).all() assert ([0, 1, 2, 3, 4, 5] == idx2[1]).all() assert [34, 11] == idx3
def test_init_results_without_results(): # should switch to "auto" mode and not fail net = example_multivoltage() pp.reset_results(net) pp.runpp(net, init="results") assert net.converged pp.reset_results(net) pp.runpp(net, init_vm_pu="results") assert net.converged pp.reset_results(net) pp.runpp(net, init_va_degree="results") assert net.converged pp.reset_results(net) pp.runpp(net, init_va_degree="results", init_vm_pu="results") assert net.converged
def test_create_realistic(): net = pn.example_multivoltage() pp.runpp(net) assert net.converged for element in [ "bus", "line", "gen", "sgen", "shunt", "trafo", "trafo3w", "load", "ext_grid", "impedance", "xward" ]: assert len(net[element]) >= 1 for et in ["l", "b", "t"]: assert len(net.switch[net.switch.et == et]) >= 1 for type_ in ["CB", "DS", "LBS"]: assert len(net.switch[net.switch.type == type_]) >= 1 assert len(net.switch[net.switch.closed]) >= 1 assert len(net.switch[~net.switch.closed]) >= 1 all_vn_kv = pd.Series([380, 110, 20, 10, 0.4]) assert net.bus.vn_kv.isin(all_vn_kv).all()
def create_net3(): """ 57 bus net with all kinds of elements. """ net = pn.example_multivoltage() net = settings_orpf(net) # Allow more loading (otherwise no valid solution) max_loading = 120 net.line['max_loading_percent'] = pd.Series( [max_loading for _ in net.line.index], index=net.line.index) max_loading = 110 net.trafo['max_loading_percent'] = pd.Series( [max_loading for _ in net.trafo.index], index=net.trafo.index) # Add maximum apparent power additional constraint (as example) for gen in ('gen', 'sgen'): max_s = (net[gen].max_p_mw**2 + net[gen].max_q_mvar**2)**0.5 net[gen]['max_s_mva'] = pd.Series(max_s, index=net[gen].index) return net
def test_voltlvl_idx(): net = pn.example_multivoltage() hv_and_mv_buses = list(range(16, 45)) assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", 4) assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", ["HV-MV"]) assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", [3, 5]) assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", ["HV", "MV"]) mv_loads = list(range(5, 13)) assert mv_loads == sb.voltlvl_idx(net, "load", "MV") hvmv_trafo3ws = [0] assert hvmv_trafo3ws == sb.voltlvl_idx(net, "trafo3w", "HV", branch_bus="hv_bus") assert hvmv_trafo3ws == sb.voltlvl_idx(net, "trafo3w", "MV", branch_bus="mv_bus") assert hvmv_trafo3ws == sb.voltlvl_idx(net, "trafo3w", "MV", branch_bus="lv_bus") ehvhv_trafos = [0] assert ehvhv_trafos == sb.voltlvl_idx(net, "trafo", 1, branch_bus="hv_bus") assert ehvhv_trafos == sb.voltlvl_idx(net, "trafo", 3, branch_bus="lv_bus") ehvhv_and_hvmv_trafos = [0] assert ehvhv_and_hvmv_trafos == sb.voltlvl_idx(net, "trafo", 2, branch_bus="hv_bus") assert ehvhv_and_hvmv_trafos == sb.voltlvl_idx(net, "trafo", 4, branch_bus="lv_bus") hvmv_trafos = [] assert hvmv_trafos == sb.voltlvl_idx(net, "trafo", 5, branch_bus="lv_bus") mvlv_trafos = [1] assert mvlv_trafos == sb.voltlvl_idx(net, "trafo", 5, branch_bus="hv_bus") lv_loads = list(range(13, 25)) assert lv_loads == sb.voltlvl_idx(net, "load", 7)
def test_multivoltage_example_with_controller(): do_output = False net = networks.example_multivoltage() gen_p_disp = 10 net.gen.p_mw.at[0] = gen_p_disp net.gen.slack_weight.at[0] = 1 net.ext_grid.slack_weight.at[0] = 1 net.trafo.tap_max.at[1] = 5 net.trafo.tap_min.at[1] = -5 ContinuousTapControl(net, tid=1, vm_set_pu=1.05) gen_disp = sum([net[elm].p_mw.sum() for elm in ["gen", "sgen"]]) load_disp = sum([net[elm].p_mw.sum() for elm in ["load", "shunt"]]) + \ net.xward[["ps_mw", "pz_mw"]].sum().sum() expected_losses = 2 # MW expected_slack_power = load_disp + expected_losses - gen_disp # MW tol = 0.5 # MW net2 = net.deepcopy() # test distributed_slack run_and_assert_numba(net) # take results for gen and xward from net to net2 and compare results net2.gen.p_mw = net.res_gen.p_mw net2.xward.ps_mw = net._ppc['bus'][ net._pd2ppc_lookups['bus'][net.xward.bus], PD] - net.load.loc[net.load.bus.isin([34, 32]), 'p_mw'].values pp.runpp(net2) assert_res_equal(net, net2) check_xward_results(net) assert_results_correct(net) if do_output: print("grid losses: %.6f" % -net.res_bus.p_mw.sum()) print("slack generator p results: %.6f %.6f" % (net.res_ext_grid.p_mw.at[0], net.res_gen.p_mw.at[0])) net.res_bus.vm_pu.plot() assert np.isclose(net.res_ext_grid.p_mw.at[0], net.res_gen.p_mw.at[0] - gen_p_disp) assert expected_slack_power / 2 - tol < net.res_ext_grid.p_mw.at[ 0] < expected_slack_power / 2 + tol losses_without_controller = -net.res_bus.p_mw.sum() slack_power_without_controller = net.res_ext_grid.p_mw.at[0] + net.res_gen.p_mw.at[0] - \ gen_p_disp # test distributed_slack with controller run_and_assert_numba(net, run_control=True) check_xward_results(net) assert_results_correct(net) losses_with_controller = -net.res_bus.p_mw.sum() expected_slack_power = slack_power_without_controller - losses_without_controller + \ losses_with_controller slack_power_without_controller = net.res_ext_grid.p_mw.at[0] + net.res_gen.p_mw.at[0] - \ gen_p_disp assert np.isclose(expected_slack_power, slack_power_without_controller, atol=1e-5) assert np.isclose(net.res_ext_grid.p_mw.at[0], expected_slack_power / 2, atol=1e-5) assert np.isclose(net.res_gen.p_mw.at[0], expected_slack_power / 2 + gen_p_disp, atol=1e-5) if do_output: print("grid losses: %.6f" % -net.res_bus.p_mw.sum()) print("slack generator p results: %.6f %.6f" % (net.res_ext_grid.p_mw.at[0], net.res_gen.p_mw.at[0])) net.res_bus.vm_pu.plot()
def test_diagnostic_report(): net = nw.example_multivoltage() net.line.loc[7, 'length_km'] = -1 net.gen.bus.at[0] = 0 net.load.p_kw.at[4] *= 1000 net.switch.closed.at[0] = 0 net.switch.closed.at[2] = 0 pp.create_switch(net, 41, 45, et='b') net.line.r_ohm_per_km.at[1] = 0 net.load.p_kw.at[0] = -1 net.switch.closed.loc[37, 38] = False net.line.x_ohm_per_km.loc[6] -= 1 net.line.from_bus.iloc[0] = 10000 pp.create_switch(net, 1, 2, et='b') diag_results = pp.diagnostic(net) diag_params = { "overload_scaling_factor": 0.001, "lines_min_length_km": 0, "lines_min_z_ohm": 0, "nom_voltage_tolerance": 0.3, "numba_tolerance": 1e-5 } diag_report = DiagnosticReports(net, diag_results, diag_params, compact_report=False) report_methods = { "missing_bus_indeces": diag_report.report_missing_bus_indeces, "disconnected_elements": diag_report.report_disconnected_elements, "different_voltage_levels_connected": diag_report.report_different_voltage_levels_connected, "lines_with_impedance_close_to_zero": diag_report.report_lines_with_impedance_close_to_zero, "nominal_voltages_dont_match": diag_report.report_nominal_voltages_dont_match, "invalid_values": diag_report.report_invalid_values, "overload": diag_report.report_overload, "multiple_voltage_controlling_elements_per_bus": diag_report.report_multiple_voltage_controlling_elements_per_bus, "wrong_switch_configuration": diag_report.report_wrong_switch_configuration, "no_ext_grid": diag_report.report_no_ext_grid, "wrong_reference_system": diag_report.report_wrong_reference_system, "deviation_from_std_type": diag_report.report_deviation_from_std_type, "numba_comparison": diag_report.report_numba_comparison, "parallel_switches": diag_report.report_parallel_switches } for key in diag_results: report_check = None try: report_methods[key]() report_check = True except: report_check = False assert report_check diag_report = DiagnosticReports(net, diag_results, diag_params, compact_report=True) for key in diag_results: report_check = None try: report_methods[key]() report_check = True except: report_check = False assert report_check
def test_net(): net = nw.example_multivoltage() return net
# -*- coding: utf-8 -*- # Copyright (c) 2016-2021 by University of Kassel and Fraunhofer Institute for Energy Economics # and Energy System Technology (IEE), Kassel. All rights reserved. # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. import pandapower.networks as nw import pandapower as pp import pandapower.control as control import os net = nw.example_multivoltage() control.DiscreteTapControl(net, 1, 1.02, 1.03) pp.runpp(net, run_control=True) pp.to_json(net, os.path.join("old_versions", "example_%s.json" % pp.__version__))
def test_voltlvl_idx(): net = pn.example_multivoltage() # add measurements pp.create_measurement(net, "v", "bus", 1.03, 0.3, net.bus.index[7]) # 380 kV pp.create_measurement(net, "v", "bus", 1.03, 0.3, net.bus.index[40]) # 10 kV pp.create_measurement(net, "i", "trafo", 0.23, 0.03, net.trafo.index[-1], "hv") # 10 kV pp.create_measurement(net, "p", "trafo", 0.33, 0.03, net.trafo.index[0], "lv") # 110 kV pp.create_measurement(net, "i", "line", 0.23, 0.03, net.line.index[-1], "to") # 0.4 kV pp.create_measurement(net, "q", "line", 0.33, 0.03, net.line.index[0], "from") # 110 kV # checking voltlvl_idx() hv_and_mv_buses = list(range(16, 45)) assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", 4) assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", ["HV-MV"]) assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", [3, 5]) assert hv_and_mv_buses == sb.voltlvl_idx(net, "bus", ["HV", "MV"]) mv_loads = list(range(5, 13)) assert mv_loads == sb.voltlvl_idx(net, "load", "MV") hvmv_trafo3ws = [0] assert hvmv_trafo3ws == sb.voltlvl_idx(net, "trafo3w", "HV", branch_bus="hv_bus") assert hvmv_trafo3ws == sb.voltlvl_idx(net, "trafo3w", "MV", branch_bus="mv_bus") assert hvmv_trafo3ws == sb.voltlvl_idx(net, "trafo3w", "MV", branch_bus="lv_bus") ehvhv_trafos = [0] assert ehvhv_trafos == sb.voltlvl_idx(net, "trafo", 1, branch_bus="hv_bus") assert ehvhv_trafos == sb.voltlvl_idx(net, "trafo", 3, branch_bus="lv_bus") ehvhv_and_hvmv_trafos = [0] assert ehvhv_and_hvmv_trafos == sb.voltlvl_idx(net, "trafo", 2, branch_bus="hv_bus") assert ehvhv_and_hvmv_trafos == sb.voltlvl_idx(net, "trafo", 4, branch_bus="lv_bus") hvmv_trafos = [] assert hvmv_trafos == sb.voltlvl_idx(net, "trafo", 5, branch_bus="lv_bus") mvlv_trafos = [1] assert mvlv_trafos == sb.voltlvl_idx(net, "trafo", 5, branch_bus="hv_bus") lv_loads = list(range(13, 25)) assert lv_loads == sb.voltlvl_idx(net, "load", 7) m1 = sb.voltlvl_idx(net, "measurement", [1]) m3 = sb.voltlvl_idx(net, "measurement", 3) m5 = sb.voltlvl_idx(net, "measurement", 5) m7 = sb.voltlvl_idx(net, "measurement", 7) assert m1 == [0] assert m3 == [3, 5] assert m5 == [1, 2] assert m7 == [4] assert len(net.measurement.index) == len(m1 + m3 + m5 + m7) assert set(net.measurement.index) == set(m1) | set(m3) | set(m5) | set(m7)
def test_repl_to_line_with_switch(): """ Same test as above, but this time in comparison to actual replacement """ net = nw.example_multivoltage() pp.runpp(net) for testindex in net.line.index: if net.line.in_service.loc[testindex]: # todo print weg print("testing line " + str(testindex)) line = net.line.loc[testindex] fbus = line.from_bus tbus = line.to_bus len = line.length_km if "184-AL1/30-ST1A" in net.line.std_type.loc[testindex]: std = "243-AL1/39-ST1A 110.0" elif "NA2XS2Y" in net.line.std_type.loc[testindex]: std = "NA2XS2Y 1x240 RM/25 6/10 kV" elif "NAYY" in net.line.std_type.loc[testindex]: std = "NAYY 4x150 SE" elif " 15-AL1/3-ST1A" in net.line.std_type.loc[testindex]: std = "24-AL1/4-ST1A 0.4" # create an oos line at the same buses REPL = pp.create_line(net, from_bus=fbus, to_bus=tbus, length_km=len, std_type=std) for bus in fbus, tbus: if bus in net.switch[(net.switch.closed == False) & (net.switch.element == testindex)].bus.values: pp.create_switch(net, bus=bus, element=REPL, closed=False, et="l", type="LBS") # calculate runpp with REPL net.line.in_service[testindex] = False net.line.in_service[REPL] = True pp.runpp(net) fbus_repl = net.res_bus.loc[fbus] tbus_repl = net.res_bus.loc[tbus] ploss_repl = (net.res_line.loc[REPL].p_from_mw - net.res_line.loc[REPL].p_to_mw ) qloss_repl =(net.res_line.loc[REPL].q_from_mvar - net.res_line.loc[REPL].q_to_mvar ) # get ne line impedances new_idx = tb.repl_to_line(net, testindex, std, in_service=True) # activate new idx line net.line.in_service[REPL] = False net.line.in_service[testindex] = True net.line.in_service[new_idx] = True pp.runpp(net) # compare lf results fbus_ne = net.res_bus.loc[fbus] tbus_ne = net.res_bus.loc[tbus] ploss_ne = (net.res_line.loc[testindex].p_from_mw - net.res_line.loc[testindex].p_to_mw)+\ (net.res_line.loc[new_idx].p_from_mw - net.res_line.loc[new_idx].p_to_mw) qloss_ne = (net.res_line.loc[testindex].q_from_mvar - net.res_line.loc[testindex].q_to_mvar )+\ (net.res_line.loc[new_idx].q_from_mvar - net.res_line.loc[new_idx].q_to_mvar) assert_series_equal(fbus_repl, fbus_ne, atol=1e-2) assert_series_equal(tbus_repl, tbus_ne) assert np.isclose(ploss_repl,ploss_ne, atol=1e-5) assert np.isclose(qloss_repl,qloss_ne) # and reset to unreinforced state again net.line.in_service[testindex] = True net.line.in_service[new_idx] = False net.line.in_service[REPL] = False