def test_merge_and_split_nets():
net1 = nw.mv_oberrhein()
# TODO there are some geodata values in oberrhein without corresponding lines
net1.line_geodata.drop(set(net1.line_geodata.index) - set(net1.line.index), inplace=True)
n1 = len(net1.bus)
pp.runpp(net1)
net2 = nw.create_cigre_network_mv()
pp.runpp(net2)
net = pp.merge_nets(net1, net2)
pp.runpp(net)
assert np.allclose(net.res_bus.vm_pu.iloc[:n1].values, net1.res_bus.vm_pu.values)
assert np.allclose(net.res_bus.vm_pu.iloc[n1:].values, net2.res_bus.vm_pu.values)
net3 = pp.select_subnet(net, net.bus.index[:n1], include_results=True)
assert pp.dataframes_equal(net3.res_bus[["vm_pu"]], net1.res_bus[["vm_pu"]])
net4 = pp.select_subnet(net, net.bus.index[n1:], include_results=True)
assert np.allclose(net4.res_bus.vm_pu.values, net2.res_bus.vm_pu.values)
def test_select_subnet():
# This network has switches of type 'l' and 't'
net = nw.create_cigre_network_mv()
# Do nothing
same_net = pp.select_subnet(net, net.bus.index)
assert pp.dataframes_equal(net.bus, same_net.bus)
assert pp.dataframes_equal(net.switch, same_net.switch)
assert pp.dataframes_equal(net.trafo, same_net.trafo)
assert pp.dataframes_equal(net.line, same_net.line)
assert pp.dataframes_equal(net.load, same_net.load)
assert pp.dataframes_equal(net.ext_grid, same_net.ext_grid)
# Remove everything
empty = pp.select_subnet(net, set())
assert len(empty.bus) == 0
assert len(empty.line) == 0
assert len(empty.load) == 0
assert len(empty.trafo) == 0
assert len(empty.switch) == 0
assert len(empty.ext_grid) == 0
# Should keep all trafo ('t') switches when buses are included
hv_buses = set(net.trafo.hv_bus)
lv_buses = set(net.trafo.lv_bus)
trafo_switch_buses = set(net.switch[net.switch.et == 't'].bus)
subnet = pp.select_subnet(net, hv_buses | lv_buses | trafo_switch_buses)
assert net.switch[net.switch.et == 't'].index.isin(subnet.switch.index).all()
# Should keep all line ('l') switches when buses are included
from_bus = set(net.line.from_bus)
to_bus = set(net.line.to_bus)
line_switch_buses = set(net.switch[net.switch.et == 'l'].bus)
subnet = pp.select_subnet(net, from_bus | to_bus | line_switch_buses)
assert net.switch[net.switch.et == 'l'].index.isin(subnet.switch.index).all()
# This network has switches of type 'b'
net2 = nw.create_cigre_network_lv()
# Should keep all bus-to-bus ('b') switches when buses are included
buses = set(net2.switch[net2.switch.et == 'b'].bus)
elements = set(net2.switch[net2.switch.et == 'b'].element)
subnet = pp.select_subnet(net2, buses | elements)
assert net2.switch[net2.switch.et == 'b'].index.isin(subnet.switch.index).all()
def create_toy_zone():
net = nw.case118()
pp.runpp(net)
vm_ext_grid = net.res_bus.loc[99, "vm_pu"]
va_ext_grid = net.res_bus.loc[99, "va_degree"]
net = get_net_118_with_zones()
areas = get_subnets(net)
net = areas[3]
net = pp.select_subnet(net, buses=net.bus.loc[net.bus.toy_zone].index)
pp.create_ext_grid(net, bus=99, vm_pu=vm_ext_grid, va_degree=va_ext_grid)
pp.runpp(net)
return net
def mv_oberrhein(scenario="load",
cosphi_load=0.98,
cosphi_pv=1.0,
include_substations=False,
separation_by_sub=False):
"""
Loads the Oberrhein network, a generic 20 kV network serviced by two 25 MVA HV/MV transformer
stations. The network supplies 141 MV/LV substations and 6 MV loads through four MV feeders.
The network layout is meshed, but the network is operated as a radial network with 6 open
sectioning points.
The network can be loaded with two different worst case scenarios for load and generation,
which are defined by scaling factors for loads / generators as well as tap positions of the
HV/MV transformers. These worst case scenarios are a good starting point for working with this
network, but you are of course free to parametrize the network for your use case.
The network also includes geographical information of lines and buses for plotting.
OPTIONAL:
**scenario** - (str, "load"): defines the scaling for load and generation
- "load": high load scenario, load = 0.6 / sgen = 0, trafo taps [-2, -3]
- "generation": high feed-in scenario: load = 0.1, generation = 0.8, trafo taps [0, 0]
**cosphi_load** - (str, 0.98): cosine(phi) of the loads
**cosphi_sgen** - (str, 1.0): cosine(phi) of the static generators
**include_substations** - (bool, False): if True, the transformers of the MV/LV level are
modelled, otherwise the loads representing the LV networks are connected directly to the
MV node
**separation_by_sub** - (bool, False): if True, the network gets separated into two
sections, referring to both substations
OUTPUT:
**net** - pandapower network
**net0, net1** - both sections of the pandapower network
EXAMPLE:
``import pandapower.networks``
``net = pandapower.networks.mv_oberrhein("generation")``
or with separation
``net0, net1 = pandapower.networks.mv_oberrhein(separation_by_sub=True)``
"""
if include_substations:
net = pp.from_json(
os.path.join(pp_dir, "networks", "mv_oberrhein_substations.json"))
else:
net = pp.from_json(
os.path.join(pp_dir, "networks", "mv_oberrhein.json"))
net.load.q_mvar = np.tan(np.arccos(cosphi_load)) * net.load.p_mw
net.sgen.q_mvar = np.tan(np.arccos(cosphi_pv)) * net.sgen.p_mw
hv_trafos = net.trafo[net.trafo.sn_mva > 1].index
if scenario == "load":
net.load.scaling = 0.6
net.sgen.scaling = 0.0
net.trafo.tap_pos.loc[hv_trafos] = [-2, -3]
elif scenario == "generation":
net.load.scaling = 0.1
net.sgen.scaling = 0.8
net.trafo.tap_pos.loc[hv_trafos] = [0, 0]
else:
raise ValueError("Unknown scenario %s - chose 'load' or 'generation'" %
scenario)
if separation_by_sub == True:
# creating multigraph
mg = top.create_nxgraph(net)
# clustering connected buses
zones = [list(area) for area in top.connected_components(mg)]
net1 = pp.select_subnet(net,
buses=zones[0],
include_switch_buses=False,
include_results=True,
keep_everything_else=True)
net0 = pp.select_subnet(net,
buses=zones[1],
include_switch_buses=False,
include_results=True,
keep_everything_else=True)
pp.runpp(net0)
pp.runpp(net1)
return net0, net1
pp.runpp(net)
return net
from __future__ import division
import math
import random
from itertools import chain
import matplotlib.pyplot as plt
import pandapower as p
import pandapower.networks as pp
import pandas as pd
net = pp.create_cigre_network_lv()
buses = chain([0], range(23, 43))
net1 = p.select_subnet(net, buses, True, False, False)
p.runpp(net1)
print(net1.load)
load_list = []
load_list.append(net1.res_load)
# load_list.remove(2)
# load_list = load_list[1:]
print(load_list)
for line in load_list:
p_kwar = line["p_kw"]
q_kwar = line["q_kvar"]
def get_subnets(net):
areas = dict()
for zone in net.bus.zone.unique():
zone_buses = net.bus.loc[net.bus.zone == zone].index
areas[zone] = pp.select_subnet(net, zone_buses)
return areas