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
