def test_case9_conversion():
net = pn.case9()
# set max_loading_percent to enable line limit conversion
net.line["max_loading_percent"] = 100
pp.runpp(net)
ppc = to_ppc(net, mode="opf")
# correction because voltage limits are set to 1.0 at slack buses
ppc["bus"][0, 12] = 0.9
ppc["bus"][0, 11] = 1.1
net2 = from_ppc(ppc, f_hz=net.f_hz)
# again add max_loading_percent to enable valid comparison
net2.line["max_loading_percent"] = 100
# compare loadflow results
pp.runpp(net)
pp.runpp(net2)
assert pp.nets_equal(net, net2, check_only_results=True, tol=1e-10)
# compare optimal powerflow results
pp.runopp(net, delta=1e-16)
pp.runopp(net2, delta=1e-16)
assert pp.nets_equal(net, net2, check_only_results=True, tol=1e-10)
def test_from_ppc():
ppc = get_testgrids('case2_2', 'ppc_testgrids.p')
net_by_ppc = from_ppc(ppc)
net_by_code = pp.from_json(os.path.join(pp.pp_dir, 'test', 'converter', 'case2_2_by_code.json'))
pp.set_user_pf_options(net_by_code) # for assertion of nets_equal
pp.runpp(net_by_ppc, trafo_model="pi")
pp.runpp(net_by_code, trafo_model="pi")
assert type(net_by_ppc) == type(net_by_code)
assert net_by_ppc.converged
assert len(net_by_ppc.bus) == len(net_by_code.bus)
assert len(net_by_ppc.trafo) == len(net_by_code.trafo)
assert len(net_by_ppc.ext_grid) == len(net_by_code.ext_grid)
assert pp.nets_equal(net_by_ppc, net_by_code, check_only_results=True, tol=1.e-9)
def test_json_encoding_decoding():
net = nw.mv_oberrhein()
net.tuple = (1, "4")
net.mg = top.create_nxgraph(net)
s = set(['1', 4])
t = tuple(['2', 3])
f = frozenset(['12', 3])
a = np.array([1., 2.])
d = {"a": net, "b": f}
json_string = json.dumps([s, t, f, net, a, d], cls=PPJSONEncoder)
s1, t1, f1, net1, a1, d1 = json.loads(json_string, cls=PPJSONDecoder)
assert s == s1
assert t == t1
assert f == f1
assert net.tuple == net1.tuple
assert np.allclose(a, a1)
# TODO line_geodata isn't the same since tuples inside DataFrames are converted to lists (see test_json_tuple_in_dataframe)
assert pp.nets_equal(net, net1, exclude_elms=["line_geodata"])
assert pp.nets_equal(d["a"], d1["a"], exclude_elms=["line_geodata"])
assert d["b"] == d1["b"]
assert_graphs_equal(net.mg, net1.mg)
def test_from_ppc():
ppc = get_testgrids('case2_2', 'ppc_testgrids.p')
net_by_ppc = from_ppc(ppc)
net_by_code = get_testgrids('case2_2_by_code', 'ppc_testgrids.p')
pp.runpp(net_by_ppc, trafo_model="pi")
pp.runpp(net_by_code, trafo_model="pi")
assert type(net_by_ppc) == type(net_by_code)
assert net_by_ppc.converged
assert len(net_by_ppc.bus) == len(net_by_code.bus)
assert len(net_by_ppc.trafo) == len(net_by_code.trafo)
assert len(net_by_ppc.ext_grid) == len(net_by_code.ext_grid)
assert pp.nets_equal(net_by_ppc,
net_by_code,
check_only_results=True,
tol=1.e-9)
def test_replace_gen_sgen():
for i in range(2):
net = nw.case9()
vm_set = [1.03, 1.02]
net.gen["vm_pu"] = vm_set
net.gen["dspf"] = 1
pp.runpp(net)
assert list(net.res_gen.index.values) == [0, 1]
# replace_gen_by_sgen
if i == 0:
pp.replace_gen_by_sgen(net)
elif i == 1:
pp.replace_gen_by_sgen(net, [0, 1], sgen_indices=[4, 1], cols_to_keep=[
"max_p_mw"], add_cols_to_keep=["dspf"]) # min_p_mw is not in cols_to_keep
assert np.allclose(net.sgen.index.values, [4, 1])
assert np.allclose(net.sgen.dspf.values, 1)
assert "max_p_mw" in net.sgen.columns
assert "min_p_mw" not in net.sgen.columns
assert not net.gen.shape[0]
assert not net.res_gen.shape[0]
assert not np.allclose(net.sgen.q_mvar.values, 0)
assert net.res_gen.shape[0] == 0
pp.runpp(net)
assert np.allclose(net.res_bus.loc[net.sgen.bus, "vm_pu"].values, vm_set)
# replace_sgen_by_gen
net2 = copy.deepcopy(net)
if i == 0:
pp.replace_sgen_by_gen(net2, [1])
elif i == 1:
pp.replace_sgen_by_gen(net2, 1, gen_indices=[2], add_cols_to_keep=["dspf"])
assert np.allclose(net2.gen.index.values, [2])
assert np.allclose(net2.gen.dspf.values, 1)
assert net2.gen.shape[0] == 1
assert net2.res_gen.shape[0] == 1
assert net2.gen.shape[0] == 1
assert net2.res_gen.shape[0] == 1
if i == 0:
pp.replace_sgen_by_gen(net, 1)
assert pp.nets_equal(net, net2)
def test_result_index_unsorted():
net = pp.create_empty_network()
pp.set_user_pf_options(net, tolerance_mva=1e-9)
b1 = pp.create_bus(net, vn_kv=0.4, index=4)
b2 = pp.create_bus(net, vn_kv=0.4, index=2)
b3 = pp.create_bus(net, vn_kv=0.4, index=3)
pp.create_gen(net, b1, p_mw=0.01, vm_pu=0.4)
pp.create_load(net, b2, p_mw=0.01)
pp.create_ext_grid(net, b3)
pp.create_line(net, from_bus=b1, to_bus=b2, length_km=0.5, std_type="NAYY 4x120 SE")
pp.create_line(net, from_bus=b1, to_bus=b3, length_km=0.5, std_type="NAYY 4x120 SE")
net_recycle = copy.deepcopy(net)
pp.runpp(net_recycle)
pp.runpp(net_recycle, recycle=dict(trafo=True, bus_pq=True, gen=True))
pp.runpp(net)
assert nets_equal(net, net_recycle, atol=1e-12)
def test_branch_switch_changes():
""" Tests replace_branch_switches() and create_branch_switches(). """
net_orig = _net_to_test()
net1 = deepcopy(net_orig)
replace_branch_switches(net1)
assert net_orig.switch.shape == net1.switch.shape
assert (net_orig.switch.bus == net1.switch.bus).all()
assert net1.bus.shape[0] == net_orig.bus.shape[0] + net_orig.switch.shape[
0] - sum(net_orig.switch.et == "b")
assert pd.Series(net1.bus.index[net1.bus.type == "auxiliary"]).isin(
net1.switch.element).all()
assert pd.Series(net1.bus.index[net1.bus.type == "auxiliary"]).isin(
set(net1.line.from_bus) | set(net1.line.to_bus)
| set(net1.trafo.hv_bus) | set(net1.trafo.lv_bus)).all()
net2 = deepcopy(net1)
create_branch_switches(net2)
assert pp.nets_equal(net_orig, net2)
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
def assert_net_equal(net1, net2, **kwargs):
"""
Raises AssertionError if grids are not equal.
"""
assert pp.nets_equal(net1, net2, **kwargs)
