def test_replace_ward_by_internal_elements(): net = nw.example_simple() pp.create_ward(net, 1, 10, 5, -20, -10, name="ward_1") pp.create_ward(net, 5, 6, 8, 10, 5, name="ward_2") pp.create_ward(net, 6, -1, 9, 11, 6, name="ward_3", in_service=False) pp.runpp(net) net_org = copy.deepcopy(net) pp.replace_ward_by_internal_elements(net) for elm in ["load", "shunt"]: assert net[elm].shape[0] == 4 res_load_created, res_shunt_created = copy.deepcopy(net.res_load), copy.deepcopy(net.res_shunt) pp.runpp(net) assert np.allclose(net_org.res_ext_grid.p_mw, net.res_ext_grid.p_mw) assert np.allclose(net_org.res_ext_grid.q_mvar, net.res_ext_grid.q_mvar) assert np.allclose(res_load_created, net.res_load) assert np.allclose(res_shunt_created, net.res_shunt) net = nw.example_simple() pp.create_ward(net, 1, 10, 5, -20, -10, name="ward_1") pp.create_ward(net, 5, 6, 8, 10, 5, name="ward_2") pp.create_ward(net, 6, -1, 9, 11, 6, name="ward_3", in_service=False) pp.runpp(net) net_org = copy.deepcopy(net) pp.replace_ward_by_internal_elements(net, [1]) for elm in ["load", "shunt"]: assert net[elm].shape[0] == 2 res_load_created, res_shunt_created = copy.deepcopy(net.res_load), copy.deepcopy(net.res_shunt) pp.runpp(net) assert np.allclose(net_org.res_ext_grid.p_mw, net.res_ext_grid.p_mw) assert np.allclose(net_org.res_ext_grid.q_mvar, net.res_ext_grid.q_mvar) assert np.allclose(res_load_created, net.res_load) assert np.allclose(res_shunt_created, net.res_shunt)
def test_kwargs_with_user_options(): net = example_simple() pp.runpp(net) assert net._options["trafo3w_losses"] == "hv" pp.set_user_pf_options(net, trafo3w_losses="lv") pp.runpp(net) assert net._options["trafo3w_losses"] == "lv"
def get_power_example_simple(): net_power = e_nw.example_simple() net_power.sgen.drop(index=0, inplace=True) net_power.load.drop(index=0, inplace=True) net_power.gen.drop(index=0, inplace=True) return net_power
def test_set_user_pf_options(): net = example_simple() pp.runpp(net) old_options = net._options.copy() test_options = {key: i for i, key in enumerate(old_options.keys())} pp.set_user_pf_options(net, hello='bye', **test_options) test_options.update({'hello': 'bye'}) assert net.user_pf_options == test_options # remove what is in user_pf_options and add hello=world pp.set_user_pf_options(net, overwrite=True, hello='world') assert net.user_pf_options == {'hello': 'world'} # check if 'hello' is added to net._options, but other options are untouched pp.runpp(net) assert 'hello' in net._options.keys() and net._options['hello'] == 'world' net._options.pop('hello') assert net._options == old_options # check if user_pf_options can be deleted and net._options is as it was before pp.set_user_pf_options(net, overwrite=True, hello='world') pp.set_user_pf_options(net, overwrite=True) assert net.user_pf_options == {} pp.runpp(net) assert 'hello' not in net._options.keys() # see if user arguments overrule user_pf_options, but other user_pf_options still have the priority pp.set_user_pf_options(net, tolerance_kva=1e-3, max_iteration=20) pp.runpp(net, tolerance_kva=1e-2) assert net.user_pf_options['tolerance_kva'] == 1e-3 assert net._options['tolerance_kva'] == 1e-2 assert net._options['max_iteration'] == 20
def test_replace_ext_grid_gen(): for i in range(2): net = nw.example_simple() net.ext_grid["uuid"] = "test" pp.runpp(net) assert list(net.res_ext_grid.index.values) == [0] # replace_ext_grid_by_gen if i == 0: pp.replace_ext_grid_by_gen(net, 0, gen_indices=[4], add_cols_to_keep=["uuid"]) elif i == 1: pp.replace_ext_grid_by_gen(net, [0], gen_indices=[4], cols_to_keep=["uuid", "max_p_mw"]) assert not net.ext_grid.shape[0] assert not net.res_ext_grid.shape[0] assert np.allclose(net.gen.vm_pu.values, [1.03, 1.02]) assert net.res_gen.p_mw.dropna().shape[0] == 2 assert np.allclose(net.gen.index.values, [0, 4]) assert net.gen.uuid.loc[4] == "test" # replace_gen_by_ext_grid if i == 0: pp.replace_gen_by_ext_grid(net) elif i == 1: pp.replace_gen_by_ext_grid(net, [0, 4], ext_grid_indices=[2, 3]) assert np.allclose(net.ext_grid.index.values, [2, 3]) assert not net.gen.shape[0] assert not net.res_gen.shape[0] assert net.ext_grid.va_degree.dropna().shape[0] == 2 assert any(np.isclose(net.ext_grid.va_degree.values, 0)) assert net.res_ext_grid.p_mw.dropna().shape[0] == 2
def test_overwrite_default_args_with_user_options(): net = example_simple() pp.runpp(net) assert net._options["check_connectivity"] is True pp.set_user_pf_options(net, check_connectivity=False) pp.runpp(net) assert net._options["check_connectivity"] is False pp.runpp(net, check_connectivity=True) assert net._options["check_connectivity"] is True
def test_replace_xward_by_internal_elements(): net = nw.example_simple() pp.create_xward(net, 1, 10, 5, -20, -10, 0.1, 0.55, 1.02, name="xward_1") pp.create_xward(net, 5, 6, 8, 10, 5, 0.009, 0.678, 1.03, name="xward_2") pp.create_xward(net, 6, 6, 8, 10, 5, 0.009, 0.678, 1.03, in_service=False, name="xward_3") pp.runpp(net) net_org = copy.deepcopy(net) pp.replace_xward_by_internal_elements(net) pp.runpp(net) assert abs(max(net_org.res_ext_grid.p_mw - net.res_ext_grid.p_mw)) < 1e-10 assert abs( max(net_org.res_ext_grid.q_mvar - net.res_ext_grid.q_mvar)) < 1e-10 net = nw.example_simple() pp.create_xward(net, 1, 10, 5, -20, -10, 0.1, 0.55, 1.02, name="xward_1") pp.create_xward(net, 5, 6, 8, 10, 5, 0.009, 0.678, 1.03, name="xward_2") pp.create_xward(net, 6, 6, 8, 10, 5, 0.009, 0.678, 1.03, in_service=False, name="xward_3") pp.runpp(net) net_org = copy.deepcopy(net) pp.replace_xward_by_internal_elements(net, [0, 1]) pp.runpp(net) assert abs(max(net_org.res_ext_grid.p_mw - net.res_ext_grid.p_mw)) < 1e-10 assert abs( max(net_org.res_ext_grid.q_mvar - net.res_ext_grid.q_mvar)) < 1e-10
def test_elements_on_path(): net = nw.example_simple() for multi in [True, False]: mg = top.create_nxgraph(net, multi=multi) path = nx.shortest_path(mg, 0, 6) assert top.elements_on_path(mg, path, "line") == [0, 3] assert top.lines_on_path(mg, path) == [0, 3] assert top.elements_on_path(mg, path, "trafo") == [0] assert top.elements_on_path(mg, path, "trafo3w") == [] assert top.elements_on_path(mg, path, "switch") == [0, 1]
def test_create_simple(): net = pn.example_simple() pp.runpp(net) assert net.converged for element in [ "bus", "line", "gen", "sgen", "shunt", "trafo", "load", "ext_grid" ]: assert len(net[element]) >= 1 for et in ["l", "b"]: assert len(net.switch[net.switch.et == et]) >= 1
def test_reindex_buses(): net_orig = nw.example_simple() net = nw.example_simple() to_add = 5 new_bus_idxs = np.array(list(net.bus.index)) + to_add bus_lookup = dict(zip(net["bus"].index.values, new_bus_idxs)) # a more complexe bus_lookup of course should also work, but this one is easy to check pp.reindex_buses(net, bus_lookup) for elm in net.keys(): if isinstance(net[elm], pd.DataFrame) and net[elm].shape[0]: cols = pd.Series(net[elm].columns) bus_cols = cols.loc[cols.str.contains("bus")] if len(bus_cols): for bus_col in bus_cols: assert all(net[elm][bus_col] == net_orig[elm][bus_col] + to_add) if elm == "bus": assert all(np.array(list(net[elm].index)) == np.array(list( net_orig[elm].index)) + to_add)
def test_get_connected_elements_dict(): net = nw.example_simple() conn = pp.get_connected_elements_dict(net, [0]) assert conn == {"line": [0], 'ext_grid': [0], 'bus': [1]} conn = pp.get_connected_elements_dict(net, [3, 4]) assert conn == { 'line': [1, 3], 'switch': [1, 2, 7], 'trafo': [0], 'bus': [2, 5, 6] }
def test_bsfw_algorithm(): net = example_simple() 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_elements_on_path(): net = nw.example_simple() for multi in [True, False]: mg = top.create_nxgraph(net, multi=multi) path = nx.shortest_path(mg, 0, 6) assert top.elements_on_path(mg, path, "line") == [0, 3] assert top.lines_on_path(mg, path) == [0, 3] assert top.elements_on_path(mg, path, "trafo") == [0] assert top.elements_on_path(mg, path, "trafo3w") == [] assert top.elements_on_path(mg, path, "switch") == [0, 1] with pytest.raises(ValueError) as exception_info: top.elements_on_path(mg, path, element="sgen") assert str(exception_info.value) == "Invalid element type sgen"
def test_bsfw_algorithm_with_trafo_shift_and_voltage_angles(): net = example_simple() net["trafo"].loc[:, "shift_degree"] = 180. pp.runpp(net, calculate_voltage_angles=True) vm_nr = net.res_bus.vm_pu va_nr = net.res_bus.va_degree pp.runpp(net, algorithm='bfsw', calculate_voltage_angles=True) 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_bsfw_algorithm_multi_net(): net = example_simple() add_grid_connection(net, vn_kv=110., zone="second") pp.runpp(net) vm_nr = copy.copy(net.res_bus.vm_pu) va_nr = copy.copy(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_no_issues(diag_params, diag_errors, report_methods): net = nw.example_simple() diag_results = pp.diagnostic(net, report_style=None) assert diag_results == {} for bool_value in [True, False]: for check_function in report_methods.keys(): diag_report = DiagnosticReports(net, diag_results, diag_errors, diag_params, compact_report=bool_value) report_check = None try: eval(report_methods[check_function]) report_check = True except: report_check = False assert report_check
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_simple(): net = pn.example_simple() pp.runpp(net) 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.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 net.converged
def test_bsfw_algorithm_with_enforce_q_lims(): net = example_simple() net.ext_grid["max_q_mvar"] = [0.1] net.ext_grid["min_q_mvar"] = [-0.1] net.gen["max_q_mvar"] = [5.] net.gen["min_q_mvar"] = [4.] pp.runpp(net, enforce_q_lims=True) vm_nr = net.res_bus.vm_pu va_nr = net.res_bus.va_degree pp.runpp(net, algorithm='bfsw', enforce_q_lims=True) 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_replace_ext_grid_gen(): net = nw.example_simple() pp.runpp(net) assert list(net.res_ext_grid.index.values) == [0] # replace_ext_grid_by_gen pp.replace_ext_grid_by_gen(net, 0) assert not net.ext_grid.shape[0] assert not net.res_ext_grid.shape[0] assert np.allclose(net.gen.vm_pu.values, [1.03, 1.02]) assert net.res_gen.p_mw.dropna().shape[0] == 2 # replace_gen_by_ext_grid pp.replace_gen_by_ext_grid(net) assert not net.gen.shape[0] assert not net.res_gen.shape[0] assert net.ext_grid.va_degree.dropna().shape[0] == 2 assert any(np.isclose(net.ext_grid.va_degree.values, 0)) assert net.res_ext_grid.p_mw.dropna().shape[0] == 2
def test_get_internal(): net = example_simple() # for Newton raphson pp.runpp(net) J_intern = net._ppc["internal"]["J"] ppc = net._ppc V_mag = ppc["bus"][:, 7][:-2] V_ang = ppc["bus"][:, 8][:-2] V = V_mag * np.exp(1j * V_ang / 180 * np.pi) # Get stored Ybus in ppc Ybus = ppc["internal"]["Ybus"] _, ppci = _pd2ppc(net) baseMVA, bus, gen, branch, ref, pv, pq, _, _, V0, _ = _get_pf_variables_from_ppci(ppci) pvpq = np.r_[pv, pq] J = _create_J_without_numba(Ybus, V, pvpq, pq) assert sum(sum(abs(abs(J.toarray()) - abs(J_intern.toarray())))) < 0.05
def test_drop_inner_branches(): def check_elm_number(net1, net2, excerpt_elms=None): excerpt_elms = set() if excerpt_elms is None else set(excerpt_elms) for elm in set(pp.pp_elements()) - excerpt_elms: assert net1[elm].shape[0] == net2[elm].shape[0] net = nw.example_simple() new_bus = pp.create_bus(net, 10) pp.create_transformer3w(net, 2, 3, new_bus, "63/25/38 MVA 110/20/10 kV") net1 = copy.deepcopy(net) tb.drop_inner_branches(net1, [2, 3], branch_elements=["line"]) check_elm_number(net1, net) tb.drop_inner_branches(net1, [0, 1], branch_elements=["line"]) check_elm_number(net1, net, ["line"]) assert all(net.line.index.difference({0}) == net1.line.index) net2 = copy.deepcopy(net) tb.drop_inner_branches(net2, [2, 3, 4, 5]) assert all(net.line.index.difference({1}) == net2.line.index) assert all(net.trafo.index.difference({0}) == net2.trafo.index) assert all(net.switch.index.difference({1, 2, 3}) == net2.switch.index) check_elm_number(net2, net, ["line", "switch", "trafo"])
def test_reindex_elements(): net = nw.example_simple() new_sw_idx = [569, 763, 502, 258, 169, 259, 348, 522] pp.reindex_elements(net, "switch", new_sw_idx) assert np.allclose(net.switch.index.values, new_sw_idx) previous_idx = new_sw_idx[:3] new_sw_idx = [2, 3, 4] pp.reindex_elements(net, "switch", new_sw_idx, previous_idx) assert np.allclose(net.switch.index.values[:3], new_sw_idx) pp.reindex_elements(net, "line", [77, 22], [2, 0]) assert np.allclose(net.line.index.values, [22, 1, 77, 3]) assert np.allclose(net.switch.element.iloc[[4, 5]], [77, 77]) old_idx = copy.deepcopy(net.bus.index.values) pp.reindex_elements(net, "bus", old_idx + 2) assert np.allclose(net.bus.index.values, old_idx + 2) pp.reindex_elements(net, "bus", [400, 600], [4, 6]) assert 400 in net.bus.index assert 600 in net.bus.index
def test_all_voltlvl_idx(): net = pn.example_simple() lvl_dicts = sb.all_voltlvl_idx(net) elms = set() for elm in pp.pp_elements(): if net[elm].shape[0]: elms |= {elm} idxs = set() for _, idx in lvl_dicts[elm].items(): idxs |= idx assert set(net[elm].index) == idxs assert elms == set(lvl_dicts.keys()) elms = ["bus"] lvl_dicts = sb.all_voltlvl_idx(net, elms=elms) assert list(lvl_dicts.keys()) == elms lvl_dicts = sb.all_voltlvl_idx(net, elms=["bus", "trafo3w"], include_empty_elms_dicts=True) assert not bool(net.trafo3w.shape[0]) assert "trafo3w" in lvl_dicts.keys()
def test_pf_algorithms(): alg_to_test = ['bfsw', 'fdbx', 'fdxb', 'gs'] for alg in alg_to_test: net = create_cigre_network_mv(with_der=False) pp.runpp(net, algorithm='nr') vm_nr = net.res_bus.vm_pu va_nr = net.res_bus.va_degree pp.runpp(net, algorithm=alg) 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) # testing with a network which contains DERs net = create_cigre_network_mv() pp.runpp(net) vm_nr = net.res_bus.vm_pu va_nr = net.res_bus.va_degree pp.runpp(net, algorithm=alg) 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) # testing a weakly meshed network and consideration of phase-shifting transformer using calculate_voltage_angles net = four_loads_with_branches_out() # adding a line in order to create a loop pp.create_line(net, from_bus=8, to_bus=9, length_km=0.05, name='line9', std_type='NAYY 4x120 SE') pp.runpp(net, calculate_voltage_angles=True) vm_nr = net.res_bus.vm_pu va_nr = net.res_bus.va_degree pp.runpp(net, algorithm=alg, calculate_voltage_angles=True) 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) # testing a network with PV buses net = example_simple() 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 _init_network(self, raw=True, config=dict()): if raw: net = pn.example_simple() else: net = config['net'] return(net)
def test_example_simple(): net = example_simple() # --- fix scaling net.load["scaling"] = 1. # --- add some additional data net.bus["subnet"] = ["net%i" % i for i in net.bus.index] pp.create_measurement(net, "i", "trafo", np.nan, np.nan, 0, "hv", name="1") pp.create_measurement(net, "i", "line", np.nan, np.nan, 1, "to", name="2") pp.create_measurement(net, "v", "bus", np.nan, np.nan, 0, name="3") net.shunt["max_step"] = np.nan stor = pp.create_storage(net, 6, 0.01, 0.1, -0.002, 0.05, 80, name="sda", min_p_mw=-0.01, max_p_mw=0.008, min_q_mvar=-0.01, max_q_mvar=0.005) net.storage.loc[stor, "efficiency_percent"] = 90 net.storage.loc[stor, "self-discharge_percent_per_day"] = 0.3 pp.create_dcline(net, 4, 6, 0.01, 0.1, 1e-3, 1.0, 1.01, name="df", min_q_from_mvar=-0.01) pp.runpp(net) to_drop = pp.create_bus(net, 7, "to_drop") # --- add names to elements for i in pp.pp_elements(): net[i] = ensure_full_column_data_existence(net, i, 'name') avoid_duplicates_in_column(net, i, 'name') # --- create geodata net.bus_geodata["x"] = [0, 1, 2, 3, 4, 5, 5, 3.63] net.bus_geodata["y"] = [0]*5+[-5, 5, 2.33] merge_busbar_coordinates(net) # --- convert csv_data = pp2csv_data(net, export_pp_std_types=True, drop_inactive_elements=True) net_from_csv_data = csv_data2pp(csv_data) # --- adjust net appearance pp.drop_buses(net, [to_drop]) del net["OPF_converged"] net.load["type"] = np.nan del net_from_csv_data["substation"] del net_from_csv_data["profiles"] for key in net.keys(): if isinstance(net[key], pd.DataFrame): # drop unequal columns dummy_columns = net[key].columns extra_columns = net_from_csv_data[key].columns.difference(dummy_columns) net_from_csv_data[key].drop(columns=extra_columns, inplace=True) # drop result table rows if "res_" in key: if not key == "res_bus": net[key].drop(net[key].index, inplace=True) else: net[key].loc[:, ["p_mw", "q_mvar"]] = np.nan # adjust dtypes if net[key].shape[0]: try: net_from_csv_data[key] = net_from_csv_data[key].astype(dtype=dict(net[ key].dtypes)) except: logger.error("dtype adjustment of %s failed." % key) eq = pp.nets_equal(net, net_from_csv_data, tol=1e-7) assert eq