def create_line_collection(net,
lines=None,
use_line_geodata=True,
infofunc=None,
cmap=None,
norm=None,
picker=False,
z=None,
cbar_title="Line Loading [%]",
**kwargs):
"""
Creates a matplotlib line collection of pandapower lines.
Input:
**net** (pandapowerNet) - The pandapower network
OPTIONAL:
**lines** (list, None) - The lines for which the collections are created. If None, all lines in the network are considered.
*use_line_geodata** (bool, True) - defines if lines patches are based on net.line_geodata of the lines (True) or on net.bus_geodata of the connected buses (False)
**infofunc** (function, None) - infofunction for the patch element
**kwargs - key word arguments are passed to the patch function
"""
lines = net.line_geodata.index.tolist() if lines is None and use_line_geodata else \
net.line.index.tolist() if lines is None and not use_line_geodata else list(lines)
if len(lines) == 0:
return None
if use_line_geodata:
data = [(net.line_geodata.coords.loc[line],
infofunc(line) if infofunc else []) for line in lines
if line in net.line_geodata.index]
else:
data = [([(net.bus_geodata.x.at[a], net.bus_geodata.y.at[a]),
(net.bus_geodata.x.at[b], net.bus_geodata.y.at[b])],
infofunc(line) if infofunc else [])
for line, (a,
b) in net.line[["from_bus", "to_bus"]].iterrows()
if line in lines and a in net.bus_geodata.index
and b in net.bus_geodata.index]
data, info = list(zip(*data))
# This would be done anyways by matplotlib - doing it explicitly makes it a) clear and
# b) prevents unexpected behavior when observing colors being "none"
lc = LineCollection(data, picker=picker, **kwargs)
lc.line_indices = np.array(lines)
if cmap:
if z is None:
z = net.res_line.loading_percent.loc[lines]
lc.set_cmap(cmap)
lc.set_norm(norm)
lc.set_array(z)
lc.has_colormap = True
lc.cbar_title = "Line Loading [%]"
lc.info = info
return lc
def create_trafo_connection_collection(net, trafos=None, bus_geodata=None, infofunc=None,
cmap=None, clim=None, norm=None, z=None,
cbar_title="Transformer Loading", **kwargs):
"""
Creates a matplotlib line collection of pandapower transformers.
Input:
**net** (pandapowerNet) - The pandapower network
OPTIONAL:
**trafos** (list, None) - The transformers for which the collections are created.
If None, all transformers in the network are considered.
**bus_geodata** (DataFrame, None) - coordinates to use for plotting
If None, net["bus_geodata"] is used
**infofunc** (function, None) - infofunction for the patch element
**kwargs - key word arguments are passed to the patch function
OUTPUT:
**lc** - line collection
"""
trafos = net.trafo if trafos is None else net.trafo.loc[trafos]
if bus_geodata is None:
bus_geodata = net["bus_geodata"]
hv_geo = list(zip(bus_geodata.loc[trafos["hv_bus"], "x"].values,
bus_geodata.loc[trafos["hv_bus"], "y"].values))
lv_geo = list(zip(bus_geodata.loc[trafos["lv_bus"], "x"].values,
bus_geodata.loc[trafos["lv_bus"], "y"].values))
tg = list(zip(hv_geo, lv_geo))
info = [infofunc(tr) if infofunc is not None else [] for tr in trafos.index.values]
lc = LineCollection([(tgd[0], tgd[1]) for tgd in tg], **kwargs)
lc.info = info
if cmap is not None:
if z is None:
z = net.res_trafo.loading_percent.loc[trafos.index]
lc.set_cmap(cmap)
lc.set_norm(norm)
if clim is not None:
lc.set_clim(clim)
lc.set_array(np.ma.masked_invalid(z))
lc.has_colormap = True
lc.cbar_title = cbar_title
return lc
def create_line_collection(net,
lines=None,
line_geodata=None,
bus_geodata=None,
use_bus_geodata=False,
infofunc=None,
cmap=None,
norm=None,
picker=False,
z=None,
cbar_title="Line Loading [%]",
clim=None,
**kwargs):
"""
Creates a matplotlib line collection of pandapower lines.
Input:
**net** (pandapowerNet) - The pandapower network
OPTIONAL:
**lines** (list, None) - The lines for which the collections are created. If None, all lines
in the network are considered.
**line_geodata** (DataFrame, None) - coordinates to use for plotting If None,
net["line_geodata"] is used
**infofunc** (function, None) - infofunction for the patch element
**kwargs - key word arguments are passed to the patch function
OUTPUT:
**lc** - line collection
"""
lines = net.line.index.tolist() if lines is None else list(lines)
if len(lines) == 0:
return None
if line_geodata is None:
line_geodata = net["line_geodata"]
if bus_geodata is None:
bus_geodata = net["bus_geodata"]
if len(lines) == 0:
return None
if use_bus_geodata:
data = [
([(bus_geodata.at[a, "x"], bus_geodata.at[a, "y"]),
(bus_geodata.at[b, "x"], bus_geodata.at[b, "y"])],
infofunc(line) if infofunc else [])
for line, (a,
b) in net.line.loc[lines,
["from_bus", "to_bus"]].iterrows()
if a in bus_geodata.index.values and b in bus_geodata.index.values
]
else:
data = [(line_geodata.loc[line, "coords"],
infofunc(line) if infofunc else []) for line in lines
if line in line_geodata.index.values]
if len(data) == 0:
return None
data, info = list(zip(*data))
# This would be done anyways by matplotlib - doing it explicitly makes it a) clear and
# b) prevents unexpected behavior when observing colors being "none"
lc = LineCollection(data, picker=picker, **kwargs)
lc.line_indices = np.array(lines)
if cmap:
if z is None:
z = net.res_line.loading_percent.loc[lines]
lc.set_cmap(cmap)
lc.set_norm(norm)
if clim is not None:
lc.set_clim(clim)
lc.set_array(np.array(z))
lc.has_colormap = True
lc.cbar_title = cbar_title
lc.info = info
return lc
def create_trafo3w_collection(net, trafo3ws=None, picker=False, infofunc=None, cmap=None, norm=None,
z=None, clim=None, cbar_title="3W-Transformer Loading",
plot_colormap=True, **kwargs):
"""
Creates a matplotlib line collection of pandapower transformers.
Input:
**net** (pandapowerNet) - The pandapower network
OPTIONAL:
**trafo3ws** (list, None) - The three winding transformers for which the collections are
created. If None, all three winding transformers in the network are considered.
**picker** (bool, False) - picker argument passed to the patch collection
**infofunc** (function, None) - infofunction for the patch element
**kwargs - key word arguments are passed to the patch function
OUTPUT:
**lc** - line collection
**pc** - patch collection
"""
trafo3ws = get_index_array(trafo3ws, net.trafo3w.index)
trafo3w_table = net.trafo3w.loc[trafo3ws]
lines = []
circles = []
infos = []
color = kwargs.pop("color", "k")
linewidth = kwargs.pop("linewidths", 2.)
if cmap is not None and z is None:
z = net.res_trafo3w.loading_percent
for i, idx in enumerate(trafo3w_table.index):
# get bus geodata
p1 = net.bus_geodata[["x", "y"]].loc[net.trafo3w.at[idx, "hv_bus"]].values
p2 = net.bus_geodata[["x", "y"]].loc[net.trafo3w.at[idx, "mv_bus"]].values
p3 = net.bus_geodata[["x", "y"]].loc[net.trafo3w.at[idx, "lv_bus"]].values
if np.all(p1 == p2) and np.all(p1 == p3):
continue
p = np.array([p1, p2, p3])
# determine center of buses and minimum distance center-buses
center = sum(p) / 3
d = np.linalg.norm(p - center, axis=1)
r = d.min() / 3
# determine closest bus to center and vector from center to circle midpoint in closest
# direction
closest = d.argmin()
to_closest = (p[closest] - center) / d[closest] * 2 * r / 3
# determine vectors from center to circle midpoint
order = list(range(closest, 3)) + list(range(closest))
cm = np.empty((3, 2))
cm[order.pop(0)] = to_closest
ang = 2 * np.pi / 3 # 120 degree
cm[order.pop(0)] = _rotate_dim2(to_closest, ang)
cm[order.pop(0)] = _rotate_dim2(to_closest, -ang)
# determine midpoints of circles
m = center + cm
# determine endpoints of circles
e = (center - p) * (1 - 5 * r / 3 / d).reshape(3, 1) + p
# save circle and line collection data
ec = color if cmap is None else cmap(norm(z.at[idx]))
for j in range(3):
circles.append(Circle(m[j], r, fc=(1, 0, 0, 0), ec=ec))
lines.append([p[j], e[j]])
if infofunc is not None:
infos.append(infofunc(i))
infos.append(infofunc(i))
if len(circles) == 0:
return None, None
lc = LineCollection(lines, color=color, picker=picker, linewidths=linewidth, **kwargs)
lc.info = infos
pc = PatchCollection(circles, match_original=True, picker=picker, linewidth=linewidth, **kwargs)
pc.info = infos
if cmap is not None:
z_duplicated = np.repeat(z.values, 3)
lc.set_cmap(cmap)
lc.set_norm(norm)
if clim is not None:
lc.set_clim(clim)
lc.set_array(np.ma.masked_invalid(z_duplicated))
lc.has_colormap = plot_colormap
lc.cbar_title = cbar_title
return lc, pc
def create_line_collection(net, lines=None, line_geodata=None, bus_geodata=None,
use_bus_geodata=False, infofunc=None,
cmap=None, norm=None, picker=False, z=None,
cbar_title="Line Loading [%]", clim=None, **kwargs):
"""
Creates a matplotlib line collection of pandapower lines.
Input:
**net** (pandapowerNet) - The pandapower network
OPTIONAL:
**lines** (list, None) - The lines for which the collections are created. If None, all lines
in the network are considered.
**line_geodata** (DataFrame, None) - coordinates to use for plotting. If None,
net["line_geodata"] is used
**bus_geodata** (DataFrame, None) - coordinates to use for plotting
If None, net["bus_geodata"] is used
**use_bus_geodata** (bool, False) - Defines whether bus or line geodata are used.
**infofunc** (function, None) - infofunction for the patch element
**cmap** - colormap for the patch colors
**norm** (matplotlib norm object, None) - matplotlib norm object
**picker** (bool, False) - picker argument passed to the patch collection
**z** (array, None) - array of bus voltage magnitudes for colormap. Used in case of given
cmap. If None net.res_bus.vm_pu is used.
**cbar_title** (str, "Bus Voltage [pu]") - colormap bar title in case of given cmap
**clim** (tuple of floats, None) - setting the norm limits for image scaling
**kwargs - key word arguments are passed to the patch function
OUTPUT:
**lc** - line collection
"""
if use_bus_geodata:
linetab = net.line if lines is None else net.line.loc[lines]
lines = net.line.index.tolist() if lines is None else list(lines)
if len(lines) == 0:
return None
if line_geodata is None:
line_geodata = net["line_geodata"]
if bus_geodata is None:
bus_geodata = net["bus_geodata"]
if len(lines) == 0:
return None
lines_with_geo = []
if use_bus_geodata:
data = []
buses_with_geodata = bus_geodata.index.values
bg_dict = bus_geodata.to_dict() #transforming to dict to make lookup faster
for line, fb, tb in zip(linetab.index, linetab.from_bus.values, linetab.to_bus.values):
if fb in buses_with_geodata and tb in buses_with_geodata:
lines_with_geo.append(line)
data.append(([(bg_dict["x"][fb], bg_dict["y"][fb]),
(bg_dict["x"][tb], bg_dict["y"][tb])],
infofunc(line) if infofunc else[]))
lines_without_geo = set(lines)-set(lines_with_geo)
if lines_without_geo:
logger.warning("Could not plot lines %s. Bus geodata is missing for those lines!"
% lines_without_geo)
else:
data = []
for line in lines:
if line in line_geodata.index.values:
lines_with_geo.append(line)
data.append((line_geodata.loc[line, "coords"], infofunc(line) if infofunc else []))
lines_without_geo = set(lines)-set(lines_with_geo)
if len(lines_without_geo) > 0:
logger.warning("Could not plot lines %s. Line geodata is missing for those lines!"
% lines_without_geo)
if len(data) == 0:
return None
data, info = list(zip(*data))
# This would be done anyways by matplotlib - doing it explicitly makes it a) clear and
# b) prevents unexpected behavior when observing colors being "none"
lc = LineCollection(data, picker=picker, **kwargs)
lc.line_indices = np.array(lines_with_geo)
if cmap is not None:
if z is None:
z = net.res_line.loading_percent.loc[lines_with_geo]
lc.set_cmap(cmap)
lc.set_norm(norm)
if clim is not None:
lc.set_clim(clim)
lc.set_array(np.array(z))
lc.has_colormap = True
lc.cbar_title = cbar_title
lc.info = info
return lc
