def printPFResults(fname): xyz = pp.from_pickle(fname) #print xyz pp.runpp(xyz) print("\nBus Flows\n-----------------\n") print xyz.res_bus print("\nLine Flows\n----------------\n") print xyz.res_line print("\nLoad Measurements\n------------------\n") #print xyz.res_load print xyz.line.index try: import seaborn colors = seaborn.color_palette() except: colors = ["b", "g", "r", "c", "y"] #plot.fuse_geodata(xyz) #plot.simple_plot(xyz, bus_size=0.7) cmap_list = [(20, "green"), (50, "yellow"), (60, "red")] cmap, norm = plot.cmap_continous(cmap_list) plot.create_generic_coordinates(xyz, respect_switches=True) lc = plot.create_line_collection(xyz, xyz.line.index, zorder=1, cmap=cmap, norm=norm, linewidths=2) plot.draw_collections([lc], figsize=(8, 6))
def plot_zones(): net = get_net_118_with_zones() areas = get_subnets(net) fig, axes = plt.subplots(1, len(areas.keys())) keys = areas.keys() keys = sorted(keys) for i, zone in enumerate(keys): net = areas[zone] collections = list() ax = axes[i] sizes = pplt.get_collection_sizes(net) collections.append(pplt.create_bus_collection(net, size=sizes["bus"])) collections.append(pplt.create_line_collection(net)) collections.append( pplt.create_trafo_collection(net, size=sizes["trafo"])) if zone == 3: collections.append( pplt.create_bus_collection(net, net.bus.loc[net.bus.toy_zone].index, color="g", size=2 * sizes["bus"], zorder=11)) pplt.draw_collections(collections, ax=ax) plt.show()
def plot_feeder(): net = nw.case118() fig, ax = plt.subplots(1, 1) mg = top.create_nxgraph(net, nogobuses=set(net.trafo.lv_bus.values)) colors = sns.color_palette() collections = list() sizes = pplt.get_collection_sizes(net) voltage_levels = net.bus.vn_kv.unique() voltage_level_colors = dict(zip(voltage_levels, colors)) legend_entries = dict() gens = set(net.gen.loc[:, "bus"].values) for area, color in zip(top.connected_components(mg), colors): vn_area = net.bus.loc[list(area)[0], "vn_kv"] color = voltage_level_colors[vn_area] legend_entries[vn_area] = color area_gens = gens - area other = area - gens collections.append( pplt.create_bus_collection(net, area_gens, color=color, size=sizes["bus"], zorder=11, patch_type="rect")) collections.append( pplt.create_bus_collection(net, other, color=color, size=sizes["bus"], zorder=11)) line_ind = net.line.loc[:, "from_bus"].isin( area) | net.line.loc[:, "to_bus"].isin(area) lines = net.line.loc[line_ind].index collections.append(pplt.create_line_collection(net, lines, color=color)) eg_vn = net.bus.at[net.ext_grid.bus.values[0], "vn_kv"] collections.append( pplt.create_ext_grid_collection(net, size=sizes["ext_grid"], color=voltage_level_colors[eg_vn])) collections.append( pplt.create_trafo_collection(net, size=sizes["trafo"], zorder=1)) pplt.draw_collections(collections, ax=ax) custom_legend(fig, entries=legend_entries) legend_entries = {"gen": "grey"} custom_legend(fig, entries=legend_entries, loc='center right', marker="s") print_info(net, fig) plt.show()
def plot_net(net, ax=None): if ax is None: fig, ax = mpl.subplots(1, 1, figsize=(10, 7)) mean_distance_between_buses = sum( (net['bus_geodata'].max() - net['bus_geodata'].min()).dropna() / 200) bus_size = mean_distance_between_buses * 1. ext_grid_size = mean_distance_between_buses * 1. trafo_size = mean_distance_between_buses * .1 collections = list() if ax is None: fig, ax = plt.subplots(1, 1) # create plot collection to visualize results cmap, norm = plt.cmap_continuous([(0.9, "blue"), (1.0, "green"), (1.1, "red")]) collections.append( plt.create_bus_collection(net, size=bus_size, cmap=cmap, norm=norm)) cmap, norm = plt.cmap_continuous([(0., "green"), (50., "yellow"), (100., "red")]) collections.append( plt.create_line_collection(net, use_bus_geodata=True, linewidth=1., cmap=cmap, norm=norm)) collections.append( plt.create_trafo_collection(net, size=trafo_size, color="green", alpha=.5)) collections.append( plt.create_ext_grid_collection(net, size=ext_grid_size, orientation=1.5)) for idx in net.bus_geodata.index: x = net.bus_geodata.loc[idx, "x"] y = net.bus_geodata.loc[idx, "y"] + bus_size * 1. ax.text(x + 0.01, y, str(idx), fontsize=8, color="k") plt.draw_collections(collections, ax=ax) mpl.tight_layout() ax.axis('off') mpl.show() mpl.close()
def plot_network(net): # create buses ID buses = net.bus.index.tolist() # list of all bus indices coords = zip(net.bus_geodata.x.loc[buses].values + 0.15, net.bus_geodata.y.loc[buses].values + 0.07) # tuples of all bus coords bic = plot.create_annotation_collection(size=0.2, texts=np.char.mod('%d', buses), coords=coords, zorder=3, color="black") # creating a color function to get a linear a colormap with color centers green at 30%, yellow at 50% and red at 60% # line loading cmap_list_lines = [(20, "green"), (50, "yellow"), (60, "red")] cmap_lines, norm_lines = plot.cmap_continuous(cmap_list_lines) # create a collection for colouring each line according to a line color range. lc = plot.create_line_collection(net, net.line.index, zorder=2, cmap=cmap_lines, norm=norm_lines, linewidths=2) # create discrete map for node pu magnitude cmap_list_nodes = [(0.975, "blue"), (1.0, "green"), (1.03, "red")] cmap_nodes, norm_nodes = plot.cmap_continuous(cmap_list_nodes) bc = plot.create_bus_collection( net, net.bus.index, size=0.07, zorder=2, cmap=cmap_nodes, norm=norm_nodes) #80 of mv obherreim and 0.07 for ieee tlc, tpc = plot.create_trafo_collection(net, net.trafo.index, color="g") sc = plot.create_bus_collection(net, net.ext_grid.bus.values, patch_type="rect", size=.08, color="y", zorder=11) # draw the different collections plot.draw_collections([lc, bc, tlc, tpc, sc, bic], figsize=(8, 6)) plt.show()
def __init__(self, net): super(SliderWidget, self).__init__() self.setupUi(self) self.net = net self.net.line_geodata.drop(set(net.line_geodata.index) - set(net.line.index), inplace=True) cmap, norm = plot.cmap_continous([(0.97, "blue"), (1.0, "green"), (1.03, "red")]) self.bc = plot.create_bus_collection(net, size=90, zorder=2, cmap=cmap, norm=norm, picker=True, infofunc=lambda x: "This is bus %s"%net.bus.name.at[x]) cmap, norm = plot.cmap_continous([(20, "green"), (50, "yellow"), (60, "red")]) self.lc = plot.create_line_collection(net, zorder=1, cmap=cmap, norm=norm, linewidths=2, infofunc=lambda x: "This is line %s"%net.line.name.at[x]) self.fig, self.ax = plt.subplots() plot.draw_collections([self.bc, self.lc], ax=self.ax) plt.close() self.canvas = FigureCanvas(self.fig) self.canvas.mpl_connect('pick_event', self.pick_event) self.gridLayout.addWidget(self.canvas) self.canvas.draw() self.LoadSlider.valueChanged.connect(self.slider_changed) self.SgenSlider.valueChanged.connect(self.slider_changed) self.setWindowTitle("PyQt with pandapower Demo")
def plot_network(net): # función que recibe una red y la grafica. colors = ["k", "b", "g", "r", "c", "y"] buses = net.bus.index.tolist() coords = zip(net.bus_geodata.x.loc[buses].values + 0.02, net.bus_geodata.y.loc[buses].values + 0.02) lc = plot.create_line_collection(net, net.line.index, color=colors[0], use_bus_geodata=True, zorder=1) bc = plot.create_bus_collection(net, net.bus.index, size=0.02, bus_geodata=None, color=colors[0], zorder=2) bic = plot.create_annotation_collection(size=0.07, texts=np.char.mod('%d', buses), coords=coords, zorder=3, color=colors[0]) tf = plot.create_trafo_collection(net, trafos=net.trafo.index, color=colors[0], size=0.04, zorder=4) sc = plot.create_bus_collection(net, net.ext_grid.bus.values, patch_type="rect", size=0.03, color=colors[2], zorder=5) ld = plot.create_load_collection(net, size=0.03) sg = plot.create_sgen_collection(net, sgens=net.sgen.index[1:], size=0.05, orientation=0) sg1 = plot.create_sgen_collection(net, sgens=[net.sgen.index[0]], size=0.05, orientation=np.pi / 2) sw = plot.create_line_switch_collection(net, size=0.04, distance_to_bus=0.08) return plot.draw_collections([lc, bc, bic, tf, sc, ld, sg, sg1, sw], figsize=(7, 10))
def simple_plot(net, respect_valves=False, pipe_width=2.0, junction_size=1.0, ext_grid_size=1.0, plot_sinks=False, plot_sources=False, sink_size=1.0, source_size=1.0, valve_size=1.0, pump_size=1.0, heat_exchanger_size=1.0, scale_size=True, junction_color="r", pipe_color='silver', ext_grid_color='orange', valve_color='silver', pump_color='silver', heat_exchanger_color='silver', library="igraph", show_plot=True, ax=None, **kwargs): # pragma: no cover """ Plots a pandapipes network as simple as possible. If no geodata is available, artificial geodata is generated. For advanced plotting see the tutorial :param net: The pandapipes format network. :type net: pandapipesNet :param respect_valves: Respect valves if artificial geodata is created. \ .. note:: This Flag is ignored if plot_line_switches is True :type respect_valves: bool default False :param pipe_width: width of pipes :type pipe_width: float, default 5.0 :param junction_size: Relative size of junctions to plot. The value junction_size is multiplied\ with mean_distance_between_buses, which equals the distance between the max geoocord\ and the min divided by 200: \ mean_distance_between_buses = sum((net['bus_geodata'].max() \ - net['bus_geodata'].min()) / 200) :type junction_size: float, default 1.0 :param ext_grid_size: Relative size of ext_grids to plot. See bus sizes for details. Note: \ ext_grids are plottet as rectangles :type ext_grid_size: float, default 1.0 :param plot_sinks: Flag to decide whether sink symbols should be drawn. :type plot_sinks: bool, default False :param plot_sources: Flag to decide whether source symbols should be drawn. :type plot_sources: bool, default False :param sink_size: Relative size of sinks to plot. :type sink_size: float, default 1.0 :param source_size: Relative size of sources to plot. :type source_size: float, default 1.0 :param valve_size: Relative size of valves to plot. :type valve_size: float, default 1.0 :param heat_exchanger_size: :type heat_exchanger_size: :param scale_size: Flag if junction_size, ext_grid_size, valve_size- and distance will be \ scaled with respect to grid mean distances :type scale_size: bool, default True :param junction_color: Junction Color. See also matplotlib or seaborn documentation on how to\ choose colors. :type junction_color: str, tuple, default "r" :param pipe_color: Pipe Color. :type pipe_color: str, tuple, default "silver" :param ext_grid_color: External Grid Color. :type ext_grid_color: str, tuple, default "orange" :param library: library name to create generic coordinates (case of missing geodata). Choose\ "igraph" to use igraph package or "networkx" to use networkx package. :type library: str, default "igraph" :param show_plot: If True, show plot at the end of plotting :type show_plot: bool, default True :param ax: matplotlib axis to plot to :type ax: object, default None :return: ax - axes of figure """ collections = create_simple_collections(net, respect_valves, pipe_width, junction_size, ext_grid_size, plot_sinks, plot_sources, sink_size, source_size, valve_size, pump_size, heat_exchanger_size, scale_size, junction_color, pipe_color, ext_grid_color, valve_color, pump_color, heat_exchanger_color, library, as_dict=False, **kwargs) ax = draw_collections(collections, ax=ax) if show_plot: plt.show() return ax
def network_plot(self, data: GridData, mode="topological_graph", pause=5): """ plot the network using matplotlib * mode = topological_graph or color_map """ if mode == "topological_graph": self.net.bus_geodata.drop(self.net.bus_geodata.index, inplace=True) self.net.line_geodata.drop(self.net.line_geodata.index, inplace=True) pplot.create_generic_coordinates(self.net) pplot.fuse_geodata(self.net) buses = self.net.bus.index.tolist() coords = zip(self.net.bus_geodata.x.loc[buses].values, self.net.bus_geodata.y.loc[buses].values) bus_layer = pplot.create_bus_collection(self.net, self.net.bus.index, size=.05, color="black", zorder=1) sub_layer = pplot.create_bus_collection( self.net, self.net.ext_grid.bus.values, patch_type="rect", size=.2, color="yellow", zorder=2) busid_layer = pplot.create_annotation_collection(size=0.2, texts=np.char.mod( '%d', buses), coords=coords, zorder=3, color="blue") line_layer = pplot.create_line_collection(self.net, self.net.line.index, color="grey", linestyles="dashed", linewidths=0.2, use_bus_geodata=True, zorder=4) lines_ergized = self.net.line[self.net.line.in_service == True].index line_ergized_layer = pplot.create_line_collection(self.net, lines_ergized, color="red", zorder=5) pplot.draw_collections([ line_layer, bus_layer, sub_layer, busid_layer, line_ergized_layer ], figsize=(8, 6)) pass if mode == "color_map": self.net.bus_geodata.drop(self.net.bus_geodata.index, inplace=True) self.net.line_geodata.drop(self.net.line_geodata.index, inplace=True) voltage_map = [((0.00, 0.90), "lime"), ((0.90, 0.950), "g"), ((0.950, 1.05), "b"), ((1.05, 1.1), "m"), ((1.1, 1.5), "r")] cmap, norm = pplot.cmap_discrete(voltage_map) pplot.create_generic_coordinates(self.net) pplot.fuse_geodata(self.net) buses = self.net.bus.index.tolist() coords = zip(self.net.bus_geodata.x.loc[buses].values, self.net.bus_geodata.y.loc[buses].values) bus_layer = pplot.create_bus_collection(self.net, self.net.bus.index, size=.05, cmap=cmap, norm=norm, color="black", zorder=1) sub_layer = pplot.create_bus_collection( self.net, self.net.ext_grid.bus.values, patch_type="rect", size=.2, color="yellow", zorder=2) busid_layer = pplot.create_annotation_collection(size=0.2, texts=np.char.mod( '%d', buses), coords=coords, zorder=3, color="blue") line_layer = pplot.create_line_collection(self.net, self.net.line.index, color="grey", linestyles="dashed", linewidths=0.2, use_bus_geodata=True, zorder=4) lines_ergized = self.net.line[self.net.line.in_service == True].index line_ergized_layer = pplot.create_line_collection(self.net, lines_ergized, color="red", zorder=5) pplot.draw_collections([ line_layer, bus_layer, sub_layer, busid_layer, line_ergized_layer ], figsize=(8, 6)) pass plt.ion() plt.plot() # put the fault lines list in the figure plt.annotate("fault lines: %s" % data.list_fault_line, (-2.3, -2.8)) if pause == 0: plt.show() else: plt.pause(pause) plt.close() pass
net.res_line_est net.res_bus net.res_bus_est net.line net.res_line_est net.res_line net.res_line = net.res_line_est net.measurement net.res_ext_grid net import pandapower as pp import pandapower.networks as nw import pandapower.plotting as plot from pandapower.plotting.plotly import simple_plotly %matplotlib inline cmap_list=[(20, "green"), (50, "yellow"), (60, "red")] cmap, norm = plot.cmap_continous(cmap_list) lc = plot.create_line_collection(net, net.line.index, zorder=1, cmap=cmap, norm=norm, linewidths=2) plot.draw_collections([lc], figsize=(8,6)) plot.simple_plot(net, show_plot=True, trafo_size = 1.5, plot_loads = True, plot_sgens = True) simple_plotly(net,respect_switches=True )
import pandapower.networks as nw import pandapower.plotting as pplt import matplotlib.pyplot as plt net = nw.create_cigre_network_mv() # limits vmax = 1.05 vmin = .95 max_ll = 100. lines = net.line.index critical = list() for l in lines: net.line.loc[l, "in_service"] = False pp.runpp(net) if net.res_bus.vm_pu.max() > vmax or net.res_bus.vm_pu.min( ) < vmin or net.res_line.loading_percent.max() > max_ll: critical.append(l) net.line.loc[l, "in_service"] = True ax = pplt.simple_plot(net, show_plot=False) clc = pplt.create_line_collection(net, critical, color="r", linewidth=3., use_bus_geodata=True) pplt.draw_collections([clc], ax=ax) plt.show()
import pandapower.networks as nw import pandapower.plotting as plot import matplotlib.pyplot as plt import seaborn colours = seaborn.color_palette() net = nw.mv_oberrhein() bc = plot.create_bus_collection(net, buses=net.bus.index, color=colours[0], size=80, zorder=1) lc = plot.create_line_collection(net, lines=net.line.index, color='grey', zorder=2) long_lines = net.line.loc[net.line.length_km > 2.].index lc1 = plot.create_line_collection(net, lines=long_lines, color=colours[2], zorder=2) plot.draw_collections([lc, bc, lc1]) plt.show()
lc = plot.create_line_collection(net, net.line.index, color="grey", zorder=1) lcl = plot.create_line_collection(net, long_lines, color=(.3, 1, .3), zorder=2) pp.runpp(net) low_voltage_buses = net.res_bus[net.res_bus.vm_pu < 0.98].index bc = plot.create_bus_collection(net, net.bus.index, size=90, color=(.2, .2, 1), zorder=10) bch = plot.create_bus_collection(net, low_voltage_buses, size=90, color=(1, 0, 0), zorder=11) plot.draw_collections([lc, lcl, bc, bch], figsize=(8, 6)) im = plt.imread("") plt.savefig('test', dpi=300) ############################################################################### ############################################################################### #""" #Stitch together Google Maps images from lat, long coordinates #Based on work by heltonbiker and BenElgar #Changes: # * updated for Python 3 # * added Google Maps API key (compliance with T&C, although can set to None) # * handle http request exceptions #"""
import pandapower as pp import pandapower.networks as nw import pandapower.plotting as plot import matplotlib.pyplot as plt from matplotlib.pyplot import get_cmap from matplotlib.colors import Normalize # load the network - test case118 from MATPOWER and run power flow to retrieve results net = nw.case118() pp.runpp(net) # create common colorbars and norms for the branches (lines) e.g. 20% line loading in green, 50% line loading in yellow cmap = get_cmap('PuBu_r') norm = Normalize(vmin=0, vmax=5) # initialize the line and bus collections lc = plot.create_line_collection(net, net.line.index, zorder=1, cmap=cmap, norm=norm) #, norm=norm, linewidths=2) bc = plot.create_bus_collection(net, net.bus.index, size=0.1, zorder=2, cmap=cmap) #, norm=norm) plot.draw_collections([lc, bc], figsize=(8,6), plot_colorbars=False) plt.show()
# Youtube Tutorial: https://www.youtube.com/watch?v=QYDp_-TX7C4 import pandapower as pp import pandapower.plotting as pplt import pandapower.topology as top import pandapower.networks as nw import matplotlib.pyplot as plt import seaborn as sns net = nw.mv_oberrhein() pplt.simple_plot(net) mg = top.create_nxgraph(net, nogobuses=set(net.trafo.lv_bus.values) | set(net.trafo.hv_bus.values)) colors = sns.color_palette() collections = list() sizes = pplt.get_collection_sizes(net) for area, color in zip(top.connected_components(mg), colors): collections.append(pplt.create_bus_collection(net, area, color=color, size=sizes["bus"])) line_ind = net.line.loc[:, "from_bus"].isin(area) | net.line.loc[:, "to_bus"].isin(area) lines = net.line.loc[line_ind].index collections.append(pplt.create_line_collection(net, lines, color=color)) collections.append(pplt.create_ext_grid_collection(net, size=sizes["ext_grid"])) pplt.draw_collections(collections) plt.show()