def plotcelldata(self, z, xlims=None, ylims=None, colorbar=True, **kwargs): """ Plot cell centered data """ ax=plt.gca() fig = plt.gcf() # Find the colorbar limits if unspecified if self.clim is None: self.clim = [z.min(),z.max()] # Set the xy limits if xlims is None or ylims is None: xlims=self.xlims() ylims=self.ylims() collection = PolyCollection(self.xy(),closed=False,**kwargs) collection.set_array(z) collection.set_clim(vmin=self.clim[0],vmax=self.clim[1]) collection.set_edgecolors(collection.to_rgba(z)) ax.add_collection(collection) ax.set_aspect('equal') ax.set_xlim(xlims) ax.set_ylim(ylims) axcb=None if colorbar: axcb = fig.colorbar(collection) return fig, ax, collection, axcb
def plotcelldata(self, z, xlims=None, ylims=None, colorbar=True, **kwargs): """ Plot cell centered data """ ax = plt.gca() fig = plt.gcf() # Find the colorbar limits if unspecified if self.clim is None: self.clim = [z.min(), z.max()] # Set the xy limits if xlims is None or ylims is None: xlims = self.xlims() ylims = self.ylims() collection = PolyCollection(self.xy(), closed=False, **kwargs) collection.set_array(z) collection.set_clim(vmin=self.clim[0], vmax=self.clim[1]) collection.set_edgecolors(collection.to_rgba(z)) ax.add_collection(collection) ax.set_aspect('equal') ax.set_xlim(xlims) ax.set_ylim(ylims) axcb = None if colorbar: axcb = fig.colorbar(collection) return fig, ax, collection, axcb
class VarPlot(object): def __init__(self, var, cmap, axes): self.axes = axes self.var = var self.cmap = cmap self.mesh = self.var.mesh self.plot_mesh() def plot_mesh(self): vertexIDs = self.mesh._orderedCellVertexIDs vertexCoords = self.mesh.vertexCoords xCoords = numerix.take(vertexCoords[0], vertexIDs) yCoords = numerix.take(vertexCoords[1], vertexIDs) polys = [] for x, y in zip(xCoords.swapaxes(0, 1), yCoords.swapaxes(0, 1)): polys.append(zip(x, y)) self.collection = PolyCollection(polys) self.collection.set_linewidth(0.5) self.axes.add_collection(self.collection) self.update(self.var) def update(self, var): rgba = self.cmap(var.value) self.collection.set_facecolors(rgba) self.collection.set_edgecolors(rgba)
def grid_plot(self): """ plotting the grid """ maxfaces = self.cells.shape[1] pointdata = self.readTXT('%s/points.dat' % self.dire) xp1 = (pointdata[:, 0] - self.originx) / 1. yp1 = (pointdata[:, 1] - self.originy) / 1. ######################################################### xp = np.zeros((self.Nc, maxfaces + 1)) yp = np.zeros((self.Nc, maxfaces + 1)) cells = self.cells.copy() #cells[cells.mask]=0 xp[:, :maxfaces] = xp1[cells] xp[range(self.Nc), self.nfaces] = xp1[cells[:, 0]] yp[:, :maxfaces] = yp1[cells] yp[range(self.Nc), self.nfaces] = yp1[cells[:, 0]] ########################################################## xy = np.zeros((maxfaces + 1, 2)) def _closepoly(ii): nf = self.nfaces[ii] + 1 xy[:nf, 0] = xp[ii, :nf] xy[:nf, 1] = yp[ii, :nf] return xy[:nf, :].copy() cellxy = [_closepoly(ii) for ii in range(self.Nc)] #xlims = np.asarray([self.xv.min(), self.xv.max()]) #ylims = np.asarray([self.yv.min(), self.yv.max()]) xlims = np.asarray([616832, 709049]) - self.originx ylims = np.asarray([2854748, 3050710]) - self.originy fig = plt.figure(figsize=(12, 10)) ax = fig.add_subplot(111) #cmap = plt.set_cmap('bwr') collection = PolyCollection(cellxy, facecolors='none') #collection.set_array(np.array(self.L[:])) collection.set_edgecolors('k') collection.set_linewidths(0.3) ax.add_collection(collection) lc = self.outline() #line collection of outline ax.add_collection(lc) ax.set_xlim(xlims) ax.set_ylim(ylims) ax.set_aspect('equal') ax.tick_params(labelsize=22) ax.set_xlabel('Easting (m)', fontsize=22) ax.set_ylabel('Northing (m)', fontsize=22) fig.tight_layout() plt.show()
class Matplotlib2DViewer(AbstractMatplotlib2DViewer): """ Displays a contour plot of a 2D `CellVariable` object. The `Matplotlib2DViewer` plots a 2D `CellVariable` using Matplotlib_. .. _Matplotlib: http://matplotlib.sourceforge.net/ """ __doc__ += AbstractMatplotlib2DViewer._test2Dirregular( viewer="Matplotlib2DViewer") def __init__(self, vars, title=None, limits={}, cmap=None, colorbar='vertical', axes=None, figaspect='auto', **kwlimits): """Creates a `Matplotlib2DViewer`. :Parameters: vars a `CellVariable` object. title displayed at the top of the `Viewer` window limits : dict a (deprecated) alternative to limit keyword arguments cmap the colormap. Defaults to `matplotlib.cm.jet` xmin, xmax, ymin, ymax, datamin, datamax displayed range of data. Any limit set to a (default) value of `None` will autoscale. colorbar plot a colorbar in specified orientation if not `None` axes if not `None`, `vars` will be plotted into this Matplotlib `Axes` object figaspect desired aspect ratio of figure. If arg is a number, use that aspect ratio. If arg is 'auto', the aspect ratio will be determined from the Variable's mesh. """ kwlimits.update(limits) AbstractMatplotlib2DViewer.__init__(self, vars=vars, title=title, figaspect=figaspect, cmap=cmap, colorbar=colorbar, axes=axes, **kwlimits) self.mesh = self.vars[0].mesh vertexIDs = self.mesh._orderedCellVertexIDs vertexCoords = self.mesh.vertexCoords xCoords = numerix.take(vertexCoords[0], vertexIDs) yCoords = numerix.take(vertexCoords[1], vertexIDs) polys = [] for x, y in zip(xCoords.swapaxes(0, 1), yCoords.swapaxes(0, 1)): if hasattr(x, 'mask'): x = x.compressed() if hasattr(y, 'mask'): y = y.compressed() polys.append(list(zip(x, y))) from matplotlib.collections import PolyCollection self.collection = PolyCollection(polys) self.collection.set_linewidth(0.5) try: self.axes.add_patch(self.collection) except: # PolyCollection not child of PatchCollection in matplotlib 0.98 self.axes.add_collection(self.collection) xmin = self._getLimit('xmin', default=xCoords.min()) xmax = self._getLimit('xmax', default=xCoords.max()) ymin = self._getLimit('ymin', default=yCoords.min()) ymax = self._getLimit('ymax', default=yCoords.max()) self.axes.set_xlim(xmin=xmin, xmax=xmax) self.axes.set_ylim(ymin=ymin, ymax=ymax) self._plot() def _getSuitableVars(self, vars): from fipy.meshes.mesh2D import Mesh2D from fipy.variables.cellVariable import CellVariable vars = [var for var in AbstractMatplotlib2DViewer._getSuitableVars(self, vars) \ if ((var.mesh.dim == 2 and isinstance(var, CellVariable)) and var.rank == 0)] if len(vars) == 0: from fipy.viewers import MeshDimensionError raise MeshDimensionError( "Matplotlib2DViewer can only display a rank-0, 2D CellVariable" ) # this viewer can only display one variable return [vars[0]] def _plot(self): ## pylab.clf() ## ## Added garbage collection since matplotlib objects seem to hang ## ## around and accumulate. ## import gc ## gc.collect() Z = self.vars[0].value self.norm.vmin = self._getLimit(('datamin', 'zmin')) self.norm.vmax = self._getLimit(('datamax', 'zmax')) rgba = self.cmap(self.norm(Z)) self.collection.set_facecolors(rgba) self.collection.set_edgecolors(rgba) if self.colorbar is not None: self.colorbar.plot() #vmin=zmin, vmax=zmax)
class Matplotlib2DViewer(_MatplotlibViewer): """ Displays a contour plot of a 2D `CellVariable` object. The `Matplotlib2DViewer` plots a 2D `CellVariable` using Matplotlib_. .. _Matplotlib: http://matplotlib.sourceforge.net/ """ __doc__ += _MatplotlibViewer._test2Dirregular(viewer="Matplotlib2DViewer") def __init__(self, vars, title=None, limits={}, cmap=None, colorbar=True, axes=None, **kwlimits): """Creates a `Matplotlib2DViewer`. :Parameters: vars a `CellVariable` object. title displayed at the top of the `Viewer` window limits : dict a (deprecated) alternative to limit keyword arguments cmap the colormap. Defaults to `matplotlib.cm.jet` xmin, xmax, ymin, ymax, datamin, datamax displayed range of data. Any limit set to a (default) value of `None` will autoscale. colorbar plot a colorbar in specified orientation if not `None` axes if not `None`, `vars` will be plotted into this Matplotlib `Axes` object """ kwlimits.update(limits) _MatplotlibViewer.__init__(self, vars=vars, title=title, figaspect=1. / 1.3, cmap=cmap, colorbar=colorbar, axes=axes, **kwlimits) self.mesh = self.vars[0].getMesh() vertexIDs = self.mesh._getOrderedCellVertexIDs() vertexCoords = self.mesh.getVertexCoords() xCoords = numerix.take(vertexCoords[0], vertexIDs) yCoords = numerix.take(vertexCoords[1], vertexIDs) polys = [] for x, y in zip(xCoords.swapaxes(0,1), yCoords.swapaxes(0,1)): if hasattr(x, 'mask'): x = x.compressed() if hasattr(y, 'mask'): y = y.compressed() polys.append(zip(x,y)) import matplotlib from matplotlib.collections import PolyCollection self.collection = PolyCollection(polys) self.collection.set_linewidth(0.5) try: self.axes.add_patch(self.collection) except: # PolyCollection not child of PatchCollection in matplotlib 0.98 self.axes.add_collection(self.collection) xmin = self._getLimit('xmin', default=xCoords.min()) xmax = self._getLimit('xmax', default=xCoords.max()) ymin = self._getLimit('ymin', default=yCoords.min()) ymax = self._getLimit('ymax', default=yCoords.max()) self.axes.set_xlim(xmin=xmin, xmax=xmax) self.axes.set_ylim(ymin=ymin, ymax=ymax) self._plot() def _getSuitableVars(self, vars): from fipy.meshes.numMesh.mesh2D import Mesh2D from fipy.variables.cellVariable import CellVariable vars = [var for var in _MatplotlibViewer._getSuitableVars(self, vars) \ if ((isinstance(var.getMesh(), Mesh2D) and isinstance(var, CellVariable)) and var.getRank() == 0)] if len(vars) == 0: from fipy.viewers import MeshDimensionError raise MeshDimensionError, "Matplotlib2DViewer can only display a rank-0, 2D CellVariable" # this viewer can only display one variable return [vars[0]] def _plot(self): ## pylab.clf() ## ## Added garbage collection since matplotlib objects seem to hang ## ## around and accumulate. ## import gc ## gc.collect() Z = self.vars[0].getValue() zmin, zmax = self._autoscale(vars=self.vars, datamin=self._getLimit(('datamin', 'zmin')), datamax=self._getLimit(('datamax', 'zmax'))) diff = zmax - zmin import matplotlib if diff == 0: rgba = self.cmap(0.5) else: rgba = self.cmap((Z - zmin) / diff) self.collection.set_facecolors(rgba) self.collection.set_edgecolors(rgba) if self.colorbar is not None: self.colorbar.plot(vmin=zmin, vmax=zmax)
class Mesh(): """ Mesh described by vertices and faces """ def __init__(self, ax, transform, vertices, faces, cmap=None, facecolors="white", edgecolors="black", linewidths=0.5, mode="front"): """ """ self.collection = PolyCollection([], clip_on=False, snap=False) self.vertices = vertices self.faces = faces self.cmap = cmap self.facecolors = mpl.colors.to_rgba_array(facecolors) self.edgecolors = mpl.colors.to_rgba_array(edgecolors) self.linewidths = linewidths self.mode = mode self.update(transform) ax.add_collection(self.collection, autolim=False) def update(self, transform): """ Update mesh according to transform (4x4 array) """ T = glm.transform(self.vertices, transform)[self.faces] Z = -T[:, :, 2].mean(axis=1) if self.cmap is not None: # Facecolors using depth buffer norm = mpl.colors.Normalize(vmin=Z.min(), vmax=Z.max()) facecolors = self.cmap(norm(Z)) else: facecolors = self.facecolors edgecolors = self.edgecolors linewidths = self.linewidths # Back face culling if self.mode == "front": front, back = glm.frontback(T) T, Z = T[front], Z[front] if len(facecolors) == len(self.faces): facecolors = facecolors[front] if len(edgecolors) == len(self.faces): edgecolors = edgecolors[front] # Front face culling elif self.mode == "back": front, back = glm.frontback(T) T, Z = T[back], Z[back] if len(facecolors) == len(faces): facecolors = facecolors[back] if len(edgecolor) == len(faces): edgecolors = edgecolors[back] # Separate 2d triangles from zbuffer triangles = T[:, :, :2] antialiased = linewidths > 0 # Sort triangles according to z buffer I = np.argsort(Z) triangles = triangles[I, :] if len(facecolors) == len(I): facecolors = facecolors[I, :] if len(edgecolors) == len(I): edgecolors = edgecolors[I, :] self.collection.set_verts(triangles) self.collection.set_linewidths(linewidths) self.collection.set_facecolors(facecolors) self.collection.set_edgecolors(edgecolors) self.collection.set_antialiased(antialiased)
class Matplotlib2DViewer(_MatplotlibViewer): """ Displays a contour plot of a 2D `CellVariable` object. The `Matplotlib2DViewer` plots a 2D `CellVariable` using Matplotlib_. .. _Matplotlib: http://matplotlib.sourceforge.net/ """ __doc__ += _MatplotlibViewer._test2Dirregular(viewer="Matplotlib2DViewer") def __init__(self, vars, title=None, limits={}, cmap=None, **kwlimits): """Creates a `Matplotlib2DViewer`. :Parameters: vars a `CellVariable` object. title displayed at the top of the `Viewer` window limits : dict a (deprecated) alternative to limit keyword arguments cmap the colormap. Defaults to `pylab.cm.jet` xmin, xmax, ymin, ymax, datamin, datamax displayed range of data. Any limit set to a (default) value of `None` will autoscale. """ kwlimits.update(limits) _MatplotlibViewer.__init__(self, vars=vars, title=title, figaspect=1. / 1.3, **kwlimits) self.colorbar = None self.mesh = self.vars[0].getMesh() vertexIDs = self.mesh._getOrderedCellVertexIDs() vertexCoords = self.mesh.getVertexCoords() xCoords = numerix.take(vertexCoords[0], vertexIDs) yCoords = numerix.take(vertexCoords[1], vertexIDs) polys = [] for x, y in zip(xCoords.swapaxes(0,1), yCoords.swapaxes(0,1)): if hasattr(x, 'mask'): x = x.compressed() if hasattr(y, 'mask'): y = y.compressed() polys.append(zip(x,y)) import pylab import matplotlib fig = pylab.figure(self.id) ax = fig.get_axes()[0] from matplotlib.collections import PolyCollection self.collection = PolyCollection(polys) self.collection.set_linewidth(0.5) try: ax.add_patch(self.collection) except: # PolyCollection not child of PatchCollection in matplotlib 0.98 ax.add_collection(self.collection) if self._getLimit('xmin') is None: xmin = xCoords.min() else: xmin = self._getLimit('xmin') if self._getLimit('xmax') is None: xmax = xCoords.max() else: xmax = self._getLimit('xmax') if self._getLimit('ymin') is None: ymin = yCoords.min() else: ymin = self._getLimit('ymin') if self._getLimit('ymax') is None: ymax = yCoords.max() else: ymax = self._getLimit('ymax') pylab.axis((xmin, xmax, ymin, ymax)) cbax, kw = matplotlib.colorbar.make_axes(ax, orientation='vertical') # Set the colormap and norm to correspond to the data for which # the colorbar will be used. if cmap is None: self.cmap = matplotlib.cm.jet else: self.cmap = cmap norm = matplotlib.colors.normalize(vmin=-1, vmax=1) # ColorbarBase derives from ScalarMappable and puts a colorbar # in a specified axes, so it has everything needed for a # standalone colorbar. There are many more kwargs, but the # following gives a basic continuous colorbar with ticks # and labels. self.cb = matplotlib.colorbar.ColorbarBase(cbax, cmap=self.cmap, norm=norm, orientation='vertical') self.cb.set_label(self.vars[0].name) self._plot() def _getSuitableVars(self, vars): from fipy.meshes.numMesh.mesh2D import Mesh2D from fipy.variables.cellVariable import CellVariable vars = [var for var in _MatplotlibViewer._getSuitableVars(self, vars) \ if ((isinstance(var.getMesh(), Mesh2D) and isinstance(var, CellVariable)) and var.getRank() == 0)] if len(vars) == 0: from fipy.viewers import MeshDimensionError raise MeshDimensionError, "Matplotlib2DViewer can only display a rank-0, 2D CellVariable" # this viewer can only display one variable return [vars[0]] def _plot(self): ## pylab.clf() ## ## Added garbage collection since matplotlib objects seem to hang ## ## around and accumulate. ## import gc ## gc.collect() Z = self.vars[0].getValue() zmin, zmax = self._autoscale(vars=self.vars, datamin=self._getLimit(('datamin', 'zmin')), datamax=self._getLimit(('datamax', 'zmax'))) diff = zmax - zmin import matplotlib if diff == 0: rgba = self.cmap(0.5) else: rgba = self.cmap((Z - zmin) / diff) self.collection.set_facecolors(rgba) self.collection.set_edgecolors(rgba) self.cb.norm = matplotlib.colors.normalize(vmin=zmin, vmax=zmax) self.cb.cmap = self.cmap self.cb.draw_all()
class Bar: """ Bar (histogram) """ def __init__(self, ax, transform, Z, facecolors="white", edgecolors="black", linewidth=0, clip=False): """ """ self.Z = Z if isinstance(facecolors, np.ndarray): shape = facecolors.shape facecolors = facecolors.reshape(-1, shape[-1]) facecolors = mpl.colors.to_rgba_array(facecolors) self.facecolors = facecolors.reshape(shape[0], shape[1], 4) else: shape = Z.shape self.facecolors = np.zeros((shape[0], shape[1], 4)) self.facecolors[...] = mpl.colors.to_rgba(facecolors) if isinstance(edgecolors, np.ndarray): shape = edgecolors.shape edgecolors = edgecolors.reshape(-1, shape[-1]) edgecolors = mpl.colors.to_rgba_array(edgecolors) self.edgecolors = edgecolors.reshape(shape[0], shape[1], 4) else: shape = Z.shape self.edgecolors = np.zeros((shape[0], shape[1], 4)) self.edgecolors[...] = mpl.colors.to_rgba(edgecolors) self.linewidth = linewidth self.xlim = -0.5, +0.50 self.ylim = -0.5, +0.50 self.zlim = -0.5, +0.50 self.clip = clip # Because all the bars have the same orientation, we can use a hack to # shade each face at once instead of computing individual face lighting. self.shade = np.array([[1.00, 1.00, 0.75, 1.00, 0.50, 1.00]]) self.collection = PolyCollection([], clip_on=self.clip, snap=False) self.update(transform) ax.add_collection(self.collection, autolim=False) def update(self, transform): """ """ Z = self.Z xmin, xmax = self.xlim ymin, ymax = self.ylim zmin, zmax = self.zlim dx, dy = 0.5 * 1 / Z.shape[0], 0.5 * 1 / Z.shape[1] # Each bar is described by 8 vertices and 6 faces V = np.zeros((Z.shape[0], Z.shape[1], 8, 3)) F = np.zeros((Z.shape[0], Z.shape[1], 6, 4), dtype=int) # Face and edge colors for the six faces FC = np.zeros((Z.shape[0], Z.shape[1], 6, 4)) FC[:, :] = self.facecolors.reshape(Z.shape[0], Z.shape[1], 1, 4) FC *= self.shade.T FC[:, :, :, 3] = 1 EC = np.zeros((Z.shape[0], Z.shape[1], 6, 4)) EC[:, :] = self.edgecolors.reshape(Z.shape[0], Z.shape[1], 1, 4) # Build vertices X, Y = np.meshgrid(np.linspace(xmin, xmax, Z.shape[0]), np.linspace(ymin, ymax, Z.shape[1])) V[..., 0] = X.reshape(Z.shape[0], Z.shape[1], 1) V[..., 1] = Y.reshape(Z.shape[0], Z.shape[1], 1) V[:, :, 0] += [+dx, +dy, zmin] V[:, :, 1] += [+dx, -dy, zmin] V[:, :, 2] += [-dx, -dy, zmin] V[:, :, 3] += [-dx, +dy, zmin] V[:, :, 4] += [+dx, +dy, zmin] V[:, :, 5] += [+dx, -dy, zmin] V[:, :, 6] += [-dx, -dy, zmin] V[:, :, 7] += [-dx, +dy, zmin] V[:, :, 4:, 2] += Z.reshape(Z.shape[0], Z.shape[1], 1) # Build faces I = 8 * np.arange(Z.shape[0] * Z.shape[1]) F[:, :] = I.reshape(Z.shape[0], Z.shape[1], 1, 1) F[:, :] += [ [0, 1, 2, 3], # -Z [0, 1, 5, 4], # +X [2, 3, 7, 6], # -X [1, 2, 6, 5], # -Y [0, 3, 7, 4], # +Y [4, 5, 6, 7] ] # +Z # Actual transformation V = V.reshape(-1, 3) V = glm.transform(V[F], transform) #[...,:2] # Depth computation # We combine the global "depth" of the bar (depth of the bottom face) # and the local depth of each face. This trick avoids problems when # sorting all the different faces. Z1 = (V[:, :, 0, :, 2].mean(axis=2)).reshape(Z.shape[0], Z.shape[1], 1) Z2 = (V[..., 2].mean(axis=3) + 10 * Z1).ravel() # Sorting I = np.argsort(-Z2) V = (V[..., :2].reshape(Z.shape[0] * Z.shape[1] * 6, 4, 2)) self.collection.set_verts(V[I]) self.collection.set_facecolors(FC.reshape(-1, 4)[I]) self.collection.set_edgecolors(EC.reshape(-1, 4)[I]) self.collection.set_linewidths(self.linewidth) if self.linewidth == 0.0: self.collection.set_antialiased(False) else: self.collection.set_antialiased(True)
class Matplotlib2DViewer(AbstractMatplotlib2DViewer): """ Displays a contour plot of a 2D `CellVariable` object. The `Matplotlib2DViewer` plots a 2D `CellVariable` using Matplotlib_. .. _Matplotlib: http://matplotlib.sourceforge.net/ """ __doc__ += AbstractMatplotlib2DViewer._test2Dirregular(viewer="Matplotlib2DViewer") def __init__(self, vars, title=None, limits={}, cmap=None, colorbar='vertical', axes=None, figaspect='auto', **kwlimits): """Creates a `Matplotlib2DViewer`. :Parameters: vars a `CellVariable` object. title displayed at the top of the `Viewer` window limits : dict a (deprecated) alternative to limit keyword arguments cmap the colormap. Defaults to `matplotlib.cm.jet` xmin, xmax, ymin, ymax, datamin, datamax displayed range of data. Any limit set to a (default) value of `None` will autoscale. colorbar plot a colorbar in specified orientation if not `None` axes if not `None`, `vars` will be plotted into this Matplotlib `Axes` object figaspect desired aspect ratio of figure. If arg is a number, use that aspect ratio. If arg is 'auto', the aspect ratio will be determined from the Variable's mesh. """ kwlimits.update(limits) AbstractMatplotlib2DViewer.__init__(self, vars=vars, title=title, figaspect=figaspect, cmap=cmap, colorbar=colorbar, axes=axes, **kwlimits) self.mesh = self.vars[0].mesh vertexIDs = self.mesh._orderedCellVertexIDs vertexCoords = self.mesh.vertexCoords xCoords = numerix.take(vertexCoords[0], vertexIDs) yCoords = numerix.take(vertexCoords[1], vertexIDs) polys = [] for x, y in zip(xCoords.swapaxes(0, 1), yCoords.swapaxes(0, 1)): if hasattr(x, 'mask'): x = x.compressed() if hasattr(y, 'mask'): y = y.compressed() polys.append(list(zip(x, y))) from matplotlib.collections import PolyCollection self.collection = PolyCollection(polys) self.collection.set_linewidth(0.5) try: self.axes.add_patch(self.collection) except: # PolyCollection not child of PatchCollection in matplotlib 0.98 self.axes.add_collection(self.collection) xmin = self._getLimit('xmin', default=xCoords.min()) xmax = self._getLimit('xmax', default=xCoords.max()) ymin = self._getLimit('ymin', default=yCoords.min()) ymax = self._getLimit('ymax', default=yCoords.max()) self.axes.set_xlim(xmin=xmin, xmax=xmax) self.axes.set_ylim(ymin=ymin, ymax=ymax) self._plot() def _getSuitableVars(self, vars): from fipy.meshes.mesh2D import Mesh2D from fipy.variables.cellVariable import CellVariable vars = [var for var in AbstractMatplotlib2DViewer._getSuitableVars(self, vars) \ if ((var.mesh.dim == 2 and isinstance(var, CellVariable)) and var.rank == 0)] if len(vars) == 0: from fipy.viewers import MeshDimensionError raise MeshDimensionError("Matplotlib2DViewer can only display a rank-0, 2D CellVariable") # this viewer can only display one variable return [vars[0]] def _plot(self): ## plt.clf() ## ## Added garbage collection since matplotlib objects seem to hang ## ## around and accumulate. ## import gc ## gc.collect() Z = self.vars[0].value self.norm.vmin = self._getLimit(('datamin', 'zmin')) self.norm.vmax = self._getLimit(('datamax', 'zmax')) rgba = self.cmap(self.norm(Z)) self.collection.set_facecolors(rgba) self.collection.set_edgecolors(rgba) if self.colorbar is not None: self.colorbar.plot() #vmin=zmin, vmax=zmax)
plt.savefig(case + '_' + str(n) + '.png', bbox_inches='tight') plt.close('all') elif 'U-chan' in case and n % 10 == 0: fig = plt.figure() ax = fig.add_subplot(111) collection = PolyCollection( xy, cmap=plt.get_cmap('jet')) # 'Blues' 'jet' 'ocean' mcm ui = self.get_center_vel(uj) uimag = np.sqrt( np.multiply(ui[:, 0], ui[:, 0]) + np.multiply(ui[:, 1], ui[:, 1])) collection.set_array(uimag) collection.set_linewidths(0.2) collection.set_edgecolors('none') collection.set_clim(vmin=0.15, vmax=0.45) ax.add_collection(collection) ax.set_xlim([-2.2, 2.5]) ax.set_ylim([-0.1, 2.6]) ax.set_aspect('equal') plt.savefig(case + '_' + str(n) + '.png', bbox_inches='tight') plt.close('all') return hi, uj, ei def get_edge_x_vel(self, uj): """ Return x direction velocity and location at cell edge midpoints """
sc.set_label('model') cb = plt.colorbar(sc) cb.set_label('Edge length (m)') plt.legend() plt.show() if '1D' not in swampy.grid_type: # Contour plot of water levels fig = plt.figure() ax = fig.add_subplot(111) xy = swampy.get_grid_poly_collection() collection = PolyCollection( xy, cmap=plt.get_cmap('jet')) # 'Blues' 'jet' 'ocean' mcm collection.set_array(ei) collection.set_linewidths(0.2) collection.set_edgecolors('k') ax.add_collection(collection) ax.set_xlim([0, domain_length]) if 'tri' in swampy.grid_type: ax.set_ylim([0, 5]) else: ax.set_ylim([0, 100]) # ax.set_xlim([400, 900]) ax.set_aspect('equal') # Contour plot of water levels and velocity vectors fig = plt.figure() ax = fig.add_subplot(111) collection = PolyCollection( xy, cmap=plt.get_cmap('jet')) # 'Blues' 'jet' 'ocean' mcm collection.set_array(ei)