def test_trirefine(): # test subdiv=2 refinement n = 3 subdiv = 2 x = np.linspace(-1., 1., n+1) x, y = np.meshgrid(x, x) x = x.ravel() y = y.ravel() mask = np.zeros(2*n**2, dtype=np.bool) mask[n**2:] = True triang = mtri.Triangulation(x, y, triangles=meshgrid_triangles(n+1), mask=mask) refiner = mtri.UniformTriRefiner(triang) refi_triang = refiner.refine_triangulation(subdiv=subdiv) x_refi = refi_triang.x y_refi = refi_triang.y n_refi = n * subdiv**2 x_verif = np.linspace(-1., 1., n_refi+1) x_verif, y_verif = np.meshgrid(x_verif, x_verif) x_verif = x_verif.ravel() y_verif = y_verif.ravel() ind1d = np.in1d(np.around(x_verif*(2.5+y_verif), 8), np.around(x_refi*(2.5+y_refi), 8)) assert_array_equal(ind1d, True) # tests the mask of the refined triangulation refi_mask = refi_triang.mask refi_tri_barycenter_x = np.sum(refi_triang.x[refi_triang.triangles], axis=1)/3. refi_tri_barycenter_y = np.sum(refi_triang.y[refi_triang.triangles], axis=1)/3. tri_finder = triang.get_trifinder() refi_tri_indices = tri_finder(refi_tri_barycenter_x, refi_tri_barycenter_y) refi_tri_mask = triang.mask[refi_tri_indices] assert_array_equal(refi_mask, refi_tri_mask)
def test_tri_smooth_contouring(): # Image comparison based on example tricontour_smooth_user. n_angles = 20 n_radii = 10 min_radius = 0.15 def z(x, y): r1 = np.sqrt((0.5-x)**2 + (0.5-y)**2) theta1 = np.arctan2(0.5-x, 0.5-y) r2 = np.sqrt((-x-0.2)**2 + (-y-0.2)**2) theta2 = np.arctan2(-x-0.2, -y-0.2) z = -(2*(np.exp((r1/10)**2)-1)*30. * np.cos(7.*theta1) + (np.exp((r2/10)**2)-1)*30. * np.cos(11.*theta2) + 0.7*(x**2 + y**2)) return (np.max(z)-z)/(np.max(z)-np.min(z)) # First create the x and y coordinates of the points. radii = np.linspace(min_radius, 0.95, n_radii) angles = np.linspace(0 + n_angles, 2*np.pi + n_angles, n_angles, endpoint=False) angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1) angles[:, 1::2] += np.pi/n_angles x0 = (radii*np.cos(angles)).flatten() y0 = (radii*np.sin(angles)).flatten() triang0 = mtri.Triangulation(x0, y0) # Delaunay triangulation z0 = z(x0, y0) xmid = x0[triang0.triangles].mean(axis=1) ymid = y0[triang0.triangles].mean(axis=1) mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0) triang0.set_mask(mask) # Then the plot refiner = mtri.UniformTriRefiner(triang0) tri_refi, z_test_refi = refiner.refine_field(z0, subdiv=4) levels = np.arange(0., 1., 0.025) plt.triplot(triang0, lw=0.5, color='0.5') plt.tricontour(tri_refi, z_test_refi, levels=levels, colors="black")
def plot_1profile_onMesh(X1, Y1, Vel1, z_min, z_max, filename): #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, sharex=True, sharey=True, subplot_kw={'projection':'3d'}, #figsize=plt.figaspect(0.5)*1.5) #fig.tight_layout() fig = plt.figure() ax = fig.gca(projection='3d') triang = tri.Triangulation(X1, Y1) #----------------------------------------------------------------------------- # Refine data #----------------------------------------------------------------------------- refiner = tri.UniformTriRefiner(triang) tri_refi, Vel1_refi = refiner.refine_field(Vel1, subdiv=3) #----------------------------------------------------------------------------- # Plot the triangulation and the high-res iso-contours #----------------------------------------------------------------------------- ax.triplot(triang, lw=0.5, color='black') ax.set_zlim(z_min, z_max) levels = np.arange(z_min, z_max, 0.025) cmap = cm.get_cmap(name='terrain', lut=None) #plt.tricontourf(tri_refi, Vel3_refi.flatten(), levels=levels, cmap=cmap) ax.plot_trisurf(X1, Y1, Vel1, cmap=cm.jet, linewidth=0.2) ax.zaxis.set_major_locator(LinearLocator(10)) ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f')) #fig.colorbar(surf, shrink=0.5, aspect=5) #plt.show() fig.savefig(filename) plt.close()
def draw_pdf_contours(axis, dist, nlevels=32, subdiv=5, **kwargs): """ 重心座標系での三角メッシュ上にpdfをheatmap表示 """ import math refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=subdiv) #pvals = [dist.pdf(xy2bc(xy)) for xy in zip(trimesh.x, trimesh.y)] xy = np.array([trimesh.x, trimesh.y]) pvals = dist.pdf(xy2bc(xy)) # 分布の最大箇所を探索 max_idx = np.argmax(pvals) xy_max = np.array(xy[:, max_idx]) #print('xy_max.shape = ', xy_max.shape) lambda_max = xy2bc(xy_max.reshape(2, 1)) lambda_max = np.array(lambda_max).flatten() #print('max_idx=', max_idx, 'xy_max = ', xy_max, 'lambda=', lambda_max ) axis.tricontourf(trimesh, pvals, nlevels, **kwargs, cmap=plt.cm.hot) axis.scatter(xy_max[0], xy_max[1], c='red', marker='o') axis.axis('equal') axis.set_xlim(0, 1) axis.set_ylim(0, 0.75**0.5) axis.axis('off')
def mesh(self, fold_under_base=True): mesh = mtri.UniformTriRefiner( self.triangle).refine_triangulation(subdiv=self.subdiv) verticies, counts = np.unique(mesh.edges, return_counts=True) l1 = verticies[np.where(counts <= 4)] # the outer layer of verticies l2, outer = inner(l1, mesh.edges) # one layer in from the edge l3, outer = inner(l2, mesh.edges, outer) # two layers in from the edge scale_x = MinMaxScaler1D() scale_x.fit(mesh.x[l3]) scale_y = MinMaxScaler1D(0, 0.75**0.5) scale_y.fit(mesh.y[l3]) mesh.x = scale_x.transform(mesh.x) mesh.y = scale_y.transform(mesh.y) if fold_under_base: mesh.x[l2] = scale_x.fit(mesh.x[l2]).transform(mesh.x[l2]) mesh.y[l2] = scale_y.fit(mesh.y[l2]).transform(mesh.y[l2]) mesh.x[l1] = .5 mesh.y[l1] = .5 self._surface_verts = np.isin(verticies, outer, invert=True) self._outer_base = l2 self._inner_base = l1 return mesh
def draw_pdf_contours(dist, border=False, nlevels=200, subdiv=8, **kwargs): '''Draws pdf contours over an equilateral triangle (2-simplex). Arguments: `dist`: A distribution instance with a `pdf` method. `border` (bool): If True, the simplex border is drawn. `nlevels` (int): Number of contours to draw. `subdiv` (int): Number of recursive mesh subdivisions to create. kwargs: Keyword args passed on to `plt.triplot`. ''' from matplotlib import ticker, cm import math refiner = tri.UniformTriRefiner(_triangle) trimesh = refiner.refine_triangulation(subdiv=subdiv) pvals = [dist.pdf(xy2bc(xy)) for xy in zip(trimesh.x, trimesh.y)] plt.tricontourf(trimesh, pvals, nlevels, **kwargs) plt.axis('equal') plt.xlim(0, 1) plt.ylim(0, 0.75**0.5) plt.axis('off') if border is True: # plt.hold(1) plt.triplot(_triangle, linewidth=1)
class simplex_dynamics: '''draws dynamics of given function and corresponding fixed points into triangle''' #corners of triangle and calculation of points r0 = np.array([0, 0]) r1 = np.array([1, 0]) r2 = np.array([1 / 2., np.sqrt(3) / 2.]) corners = np.array([r0, r1, r2]) triangle = tri.Triangulation(corners[:, 0], corners[:, 1]) refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=5) trimesh_fine = refiner.refine_triangulation(subdiv=5) def __init__(self, fun): self.f = fun # self.calculate_stationary_points() self.calc_direction_and_strength() #barycentric coordinates def xy2ba(self, x, y): corner_x = self.corners.T[0] corner_y = self.corners.T[1] x_1 = corner_x[0] x_2 = corner_x[1] x_3 = corner_x[2] y_1 = corner_y[0] y_2 = corner_y[1] y_3 = corner_y[2] l1 = ((y_2 - y_3) * (x - x_3) + (x_3 - x_2) * (y - y_3)) / ((y_2 - y_3) * (x_1 - x_3) + (x_3 - x_2) * (y_1 - y_3)) l2 = ((y_3 - y_1) * (x - x_3) + (x_1 - x_3) * (y - y_3)) / ((y_2 - y_3) * (x_1 - x_3) + (x_3 - x_2) * (y_1 - y_3)) l3 = 1 - l1 - l2 return np.array([l1, l2, l3]) def ba2xy(self, x): ### x: array of 3-dim ba coordinates ### corners: coordinates of corners of ba coordinate system x = np.array(x) # print(self.corners.shape) # print(self.corners.T) # print(x) return self.corners.T.dot(x.T).T def calc_direction_and_strength(self): direction = [ self.f(self.xy2ba(x, y), 0) for x, y in zip(self.trimesh.x, self.trimesh.y) ] self.direction_norm = np.array([ self.ba2xy(v) / np.linalg.norm(v) if np.linalg.norm(v) > 0 else np.array([0, 0]) for v in direction ]) self.direction_norm = self.direction_norm #print(direction_ba_norm) self.pvals = [np.linalg.norm(v) for v in direction] self.direction = np.array([self.ba2xy(v) for v in direction]) def plot_simplex(self, ax, cmap='viridis', typelabels=["A", "B", "C"], **kwargs): ax.triplot(self.triangle, linewidth=0.8, color="black") ax.tricontourf(self.trimesh, self.pvals, alpha=0.8, cmap=cmap, **kwargs) #arrow plot options: # Q = ax.quiver(self.trimesh.x, self.trimesh.y, self.direction_norm.T[0],self.direction_norm.T[1],self.pvals,angles='xy',pivot='mid', cmap=cmap)#pivot='tail', Q = ax.quiver(self.trimesh.x, self.trimesh.y, self.direction_norm.T[0], self.direction_norm.T[1], angles='xy', pivot='mid') #pivot='tail')# # Q = ax.quiver(self.trimesh.x, self.trimesh.y, self.direction.T[0],self.direction.T[1],angles='xy',pivot='mid')#pivot='tail')# ax.axis('equal') ax.axis('off') margin = 0.01 ax.set_ylim(ymin=-margin, ymax=self.r2[1] + margin) ax.set_xlim(xmin=-margin, xmax=1. + margin) #timescatter=ax.scatter(points[::5,0],points[::5,1],c=t[::5],linewidth=0.0,cmap='viridis',alpha=.5) # if self.fixpoints.shape[0]>0: # ax.scatter(self.fixpoints[:,0],self.fixpoints[:,1],c="black",s=70,linewidth=0.3) #fig.colorbar(timescatter,label="time") ax.annotate(typelabels[0], (0, 0), xytext=(-0.0, -0.02), horizontalalignment='center', va='top') ax.annotate(typelabels[1], (1, 0), xytext=(1.0, -0.02), horizontalalignment='center', va='top') ax.annotate(typelabels[2], self.corners[2], xytext=self.corners[2] + np.array([0.0, 0.02]), horizontalalignment='center', va='bottom')
def plot_to_file_3profiles(X1, Y1, X2, Y2, Vel1, Vel2, Vel3, z_min, z_max, filename): #ax1 = fig.gca(projection='3d') #ax2 = fig.gca(projection='3d') #fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True, projection='3d') #fig = plt.figure() # figaspect(0.5) makes the figure twice as wide as it is tall. # Then the *1.5 increases the size of the figure. # The labels etc won't increase so this is a way to make the graph look less cluttered by the labels. #fig = plt.figure(figsize=plt.figaspect(0.5)*1.5) #ax1 = fig.add_subplot(121, projection='3d') #ax2 = fig.add_subplot(122, projection='3d') fig, (ax1, ax2, ax3) = plt.subplots(1, 3, sharex=True, sharey=True, subplot_kw={'projection': '3d'}, figsize=plt.figaspect(0.5) * 1.5) fig.tight_layout() Xtmp1, Ytmp1 = np.meshgrid(X1, Y1) surf = ax1.plot_surface(Xtmp1, Ytmp1, Vel1, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False) surf = ax2.plot_surface(Xtmp1, Ytmp1, Vel2, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False) ax1.set_zlim(z_min, z_max) ax2.set_zlim(z_min, z_max) triang = tri.Triangulation(X2, Y2) #----------------------------------------------------------------------------- # Refine data #----------------------------------------------------------------------------- refiner = tri.UniformTriRefiner(triang) tri_refi, Vel3_refi = refiner.refine_field(Vel3, subdiv=3) #print(X2.shape) #print(Y2.shape) #print(Vel3.shape) #----------------------------------------------------------------------------- # Plot the triangulation and the high-res iso-contours #----------------------------------------------------------------------------- #plt.figure() #plt.gca().set_aspect('equal') ax3.triplot(triang, lw=0.5, color='black') levels = np.arange(z_min, z_max, 0.025) cmap = cm.get_cmap(name='terrain', lut=None) #plt.tricontourf(tri_refi, Vel3_refi.flatten(), levels=levels, cmap=cmap) ax3.plot_trisurf(X2, Y2, Vel3, cmap=cm.jet, linewidth=0.2) #print(Vel3) #plt.tricontourf(tri_refi, Vel3_refi, levels=levels, cmap=cmap) #plt.tricontour(tri_refi, z_test_refi, levels=levels, #colors=['0.25', '0.5', '0.5', '0.5', '0.5'], #linewidths=[1.0, 0.5, 0.5, 0.5, 0.5]) ax1.zaxis.set_major_locator(LinearLocator(10)) ax1.zaxis.set_major_formatter(FormatStrFormatter('%.02f')) ax2.zaxis.set_major_locator(LinearLocator(10)) ax2.zaxis.set_major_formatter(FormatStrFormatter('%.02f')) ax3.zaxis.set_major_locator(LinearLocator(10)) ax3.zaxis.set_major_formatter(FormatStrFormatter('%.02f')) fig.colorbar(surf, shrink=0.5, aspect=5) #plt.show() fig.savefig(filename) plt.close()
import matplotlib.tri as pytri import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm from math import sqrt fig = plt.figure() tri = pytri.Triangulation([1, -sqrt(3)/2, -sqrt(3)/2], [0, 0.5, -0.5]) ref = pytri.UniformTriRefiner(tri) phi0 = [1, 0, 0] phi1 = [0, 1, 0] phi2 = [0, 0, 1] shadow = [0, 0, 0] rtri, rphi0 = ref.refine_field(phi0, subdiv=4) rtri, rphi1 = ref.refine_field(phi1, subdiv=4) rtri, rphi2 = ref.refine_field(phi2, subdiv=4) ax = fig.add_subplot(131, projection='3d') ax.plot_trisurf(rtri, rphi0, cmap=cm.coolwarm) ax.plot_trisurf(tri, shadow) ax = fig.add_subplot(132, projection='3d') ax.plot_trisurf(rtri, rphi1, cmap=cm.coolwarm) ax.plot_trisurf(tri, shadow) ax = fig.add_subplot(133, projection='3d') ax.plot_trisurf(rtri, rphi2, cmap=cm.coolwarm) ax.plot_trisurf(tri, shadow) plt.show()
def plot(distribution, method='stick', short=False, lingrid=None, bins=100, subdiv=6, levels=100): """ Visualizes a distribution on the 1D or 2D probability simplex. The distribution can be either provided parametrically as a Gaussian or in form of a collection of samples. Parameters ---------- distribution: Either an [N x M] array representing N samples from the distribution or a tuple (mean, cov) containing the parameters of the Gaussian. The dimensionality of the Gaussian / the value M depend on the number of categories and/or the specified transformation method, see 'gaussian2simplex' and 'realsamples2simplex'. method: Either 'stick', 'logistic', 'softmax' or 'direct'. If 'direct', the methods are assumed to be provided directly on the simplex. For the other options, see 'realsamples2simplex'. If the distribution is specified parametrically, 'stick' is assumed. short: Only relevant for method='direct'. If true it is assumed that the last (dependent) entry of each sample has already been dropped. lingrid: grid for plotting 1D densities computed from parametric Gaussians bins: number of bins for plotting 1D densities computed from samples subdiv: grid granularity for plotting 2D densities levels: value granularity for plotting 2D densities """ method = method.lower() if isinstance(distribution, tuple): parametric = True mean, cov = map(lambda x: np.array(x), distribution) dim = mean.shape[0] + 1 assert method == 'stick' else: parametric = False samples = np.array(distribution) # type of samples if method == 'direct': # samples are directly provided on probability simplex if short: p = np.c_[samples, 1 - samples.sum(axis=1)] else: p = samples else: # map samples to probability simplex p = realsamples2simplex(samples, method) dim = p.shape[1] # two categories if dim == 2: # if distribution is parametrized as Gaussian if parametric: # plotting grid if lingrid is None: lingrid = np.linspace(0, 1, 100) # corresponding points on two-dimensional simplex (last entry dropped) pshort = lingrid[:, None] # evaluate density on simplex points density = gaussian2simplex(mean, cov, pshort, short=True) # visualization plt.plot(lingrid, density) # otherwise (distribution given in form of samples) else: # visualization plt.hist(p[:, 0], bins=bins, range=(0, 1), density=True) # three categories elif dim == 3: # define simplex triangle corners = np.array([[0, 0], [1, 0], [0.5, np.sin(np.pi / 3)]]) triangle = tri.Triangulation(*corners.T) # get simplex grid refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=subdiv) grid = np.c_[trimesh.x, trimesh.y] # compute Delaunay triangulation D = spa.Delaunay(grid) # if distribution is parametrized as Gaussian if parametric: p = xy2bc(grid, corners) density = gaussian2simplex(mean, cov, p) visualizationMesh = trimesh # otherwise (distribution given in form of samples) else: # get xy-Cartesian coordinates of simplex points xy = bc2xy(p, corners) # compute histogram on the triangulation simplexes simplexInds = D.find_simplex(xy) density = np.bincount(simplexInds, minlength=D.nsimplex) / samples.shape[0] # compute center points of triangulation centerPoints = np.zeros((D.nsimplex, 2)) for vInd, v in enumerate(D.vertices): centerPoints[vInd] = D.points[D.vertices[vInd]].mean(axis=0) # mesh for visualization, defined on the center points of the original triangulation visualizationMesh = tri.Triangulation(centerPoints[:, 0], centerPoints[:, 1]) # visualization plt.tricontourf(visualizationMesh, density, levels) plt.text(*corners[0], '(1,0,0)', verticalalignment='top', horizontalalignment='right') plt.text(*corners[1], '(0,1,0)', verticalalignment='top', horizontalalignment='left') plt.text(*corners[2], '(0,0,1)', verticalalignment='bottom', horizontalalignment='center') plt.title(method, loc='right') else: raise ValueError('wrong input dimension')
def triangleplot(surf_points, surf_data, norm, surf_axis_scale = 1, cmap = 'RdBu_r', cbar_label = '', saveas = None, surf_levels = None, scatter_points=None, scatter_color = None, cbar_spacing = None, cbar_ticks = None): mpl.rcParams.update({'font.size': 8}) mpl.rcParams.update({'font.sans-serif': 'Arial', 'font.family': 'sans-serif'}) b=surf_points[:,0] c=surf_points[:,1] a=surf_points[:,2] # values stored in the last column v = np.squeeze(surf_data)/surf_axis_scale#[:,-1]/surf_axis_scale # translate the data to cartesian x = 0.5 * ( 2.*b+c ) / ( a+b+c ) y = 0.5*np.sqrt(3) * c / (a+b+c) # create a triangulation T = tri.Triangulation(x,y) fig, ax = plt.subplots(nrows=1, ncols=1) fig.set_figheight(3.6/2.54) fig.set_figwidth(5/2.54) plt.subplots_adjust(left=0.05, right=0.85, bottom=0.14, top=0.91) if scatter_points is not None: #Triangulation for the points suggested by BO. b_p = scatter_points[:,0] c_p = scatter_points[:,1] a_p = scatter_points[:,2] x_p = 0.5 * ( 2.*b_p+c_p ) / ( a_p+b_p+c_p) y_p = 0.5*np.sqrt(3) * c_p / (a_p+b_p+c_p) im3 = ax.scatter(x_p, y_p, s=8, c=scatter_color, cmap=cmap, edgecolors='black', linewidths=.5, alpha=1, zorder=2, norm=norm) # plot the contour if surf_levels is None: # im=ax.tricontourf(x,y,T.triangles,v, cmap=cmap, levels=surf_levels) #else: nlevels = 8 minvalue = 0 if norm.vmin < minvalue: minvalue = norm.vmin if norm.vmin > (minvalue + ((norm.vmax-minvalue)/nlevels)): minvalue = norm.vmin surf_levels = np.arange(minvalue, norm.vmax, (norm.vmax-minvalue)/nlevels) surf_levels = np.round(surf_levels, -int(np.floor(np.log10(norm.vmax))-1))#2)) surf_levels = np.append(surf_levels, 2*surf_levels[-1] - surf_levels[-2]) im=ax.tricontourf(x,y,T.triangles,v, cmap=cmap, levels=surf_levels) myformatter=matplotlib.ticker.ScalarFormatter() myformatter.set_powerlimits((0,2)) if cbar_spacing is not None: cbar=plt.colorbar(im, ax=ax, spacing=cbar_spacing, ticks=cbar_ticks) else: cbar=plt.colorbar(im, ax=ax, format=myformatter, spacing=surf_levels, ticks=surf_levels) cbar.set_label(cbar_label)#, labelpad = -0.5) plt.axis('off') plt.text(0.35,-0.1,'Cs (%)') plt.text(0.10,0.54,'FA (%)', rotation=61) plt.text(0.71,0.51,'MA (%)', rotation=-61) plt.text(-0.0, -0.1, '0') plt.text(0.87, -0.1, '100') plt.text(-0.07, 0.13, '100', rotation=61) plt.text(0.39, 0.83, '0', rotation=61) plt.text(0.96, 0.05, '0', rotation=-61) plt.text(0.52, 0.82, '100', rotation=-61) # create the grid corners = np.array([[0, 0], [1, 0], [0.5, np.sqrt(3)*0.5]]) triangle = tri.Triangulation(corners[:, 0], corners[:, 1]) # creating the grid refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=0) #plotting the mesh im2=ax.triplot(trimesh,'k-', linewidth=0.5) if saveas: fig.savefig(results_dir + saveas + '.pdf', transparent = True) fig.savefig(results_dir + saveas + '.svg', transparent = True) fig.savefig(results_dir + saveas + '.png', dpi=300) plt.show() return fig, ax
def plot_energies_contour(sites, e_seg, figname, r, cmtype='viridis', refine=False, units='eV', figformat='tif', levels=100, nticks=4, vmin=np.nan, vmax=np.nan): '''Produces a contour plot of the segregation energy at sites around a dislocation. Use <levels> to control the number of contours. ''' # create contour plot of segregation energies using a Delauney triangulation # scheme x = sites[:, 1] y = sites[:, 2] triang = tri.Triangulation(x, y) fig = plt.figure() plt.gca().set_aspect('equal') if not (vmin is np.nan) and not (vmax is np.nan): # both vmin and vmax are defined ticks = np.linspace(vmin, vmax, nticks, endpoint=True) normalize = colors.Normalize(vmin=vmin, vmax=vmax) levels = np.linspace(vmin, vmax, levels) elif vmin is np.nan and not (vmax is np.nan): # only vmax is defined => use minimum value of e_seg for vmin ticks = np.linspace(min(e_seg), vmax, nticks, endpoint=True) normalize = colors.Normalize(vmin=min(e_seg), vmax=vmax) levels = np.linspace(min(e_seg), vmax, levels) elif not (vmin is np.nan) and vmax is np.nan: # only vmin is defined => use maximum value of e_seg for vmax ticks = np.linspace(vmin, max(e_seg), nticks, endpoint=True) normalize = colors.Normalize(vmin=vmin, vmax=max(e_seg)) levels = np.linspace(vmin, max(e_seg), levels) else: ticks = np.linspace(min(e_seg), max(e_seg), nticks, endpoint=True) normalize = colors.Normalize(vmin=min(e_seg), vmax=max(e_seg)) levels = np.linspace(min(e_seg), max(e_seg), levels) # plot energy contours if refine: # refine data for improved high-res plot refiner = tri.UniformTriRefiner(triang) points, values = refiner.refine_field(e_seg, subdiv=3) else: # use raw data to produce contours points, values = triang, e_seg #if vmin != vmin and vmax != vmax: # plt.tricontourf(points, values, levels, cmap=plt.get_cmap(cmtype)) #else: plt.tricontourf(points, values, levels, cmap=plt.get_cmap(cmtype), norm=normalize) plt.xlabel('x ($\AA$)', size='x-large', family='serif') plt.ylabel('y ($\AA$)', size='x-large', family='serif') cb = plt.colorbar(format='%.2f', ticks=ticks) cb.set_label('E ({})'.format(units), size='x-large', family='serif', weight='semibold') # add points to mark the locations of the atomic sites plt.scatter(x, y, s=60, linewidth='2', facecolors='none', edgecolors='k') plt.xlim(-r - 1, r + 1) plt.ylim(-r - 1, r + 1) plt.tight_layout() plt.savefig('{}.{}'.format(figname, figformat), dpi=400) plt.close() return
def example7(): #----------------------------------------------------------------------------- # Analytical test function #----------------------------------------------------------------------------- def function_z(x, y): r1 = np.sqrt((0.5 - x)**2 + (0.5 - y)**2) theta1 = np.arctan2(0.5 - x, 0.5 - y) r2 = np.sqrt((-x - 0.2)**2 + (-y - 0.2)**2) theta2 = np.arctan2(-x - 0.2, -y - 0.2) z = -(2 * (np.exp( (r1 / 10)**2) - 1) * 30. * np.cos(7. * theta1) + (np.exp( (r2 / 10)**2) - 1) * 30. * np.cos(11. * theta2) + 0.7 * (x**2 + y**2)) return (np.max(z) - z) / (np.max(z) - np.min(z)) #----------------------------------------------------------------------------- # Creating a Triangulation #----------------------------------------------------------------------------- # First create the x and y coordinates of the points. n_angles = 20 n_radii = 10 min_radius = 0.15 radii = np.linspace(min_radius, 0.95, n_radii) angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False) angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1) angles[:, 1::2] += np.pi / n_angles x = (radii * np.cos(angles)).flatten() y = (radii * np.sin(angles)).flatten() z = function_z(x, y) # Now create the Triangulation. # (Creating a Triangulation without specifying the triangles results in the # Delaunay triangulation of the points.) triang = tri.Triangulation(x, y) # Mask off unwanted triangles. triang.set_mask( np.hypot(x[triang.triangles].mean(axis=1), y[triang.triangles].mean( axis=1)) < min_radius) #----------------------------------------------------------------------------- # Refine data #----------------------------------------------------------------------------- refiner = tri.UniformTriRefiner(triang) tri_refi, z_test_refi = refiner.refine_field(z, subdiv=3) #----------------------------------------------------------------------------- # Plot the triangulation and the high-res iso-contours #----------------------------------------------------------------------------- fig, ax = plt.subplots() ax.set_aspect('equal') ax.triplot(triang, lw=0.5, color='white') levels = np.arange(0., 1., 0.025) cmap = cm.get_cmap(name='terrain', lut=None) ax.tricontourf(tri_refi, z_test_refi, levels=levels, cmap=cmap) ax.tricontour(tri_refi, z_test_refi, levels=levels, colors=['0.25', '0.5', '0.5', '0.5', '0.5'], linewidths=[1.0, 0.5, 0.5, 0.5, 0.5]) ax.set_title("High-resolution tricontouring") return getSVG(plt)
def plotzero(): handles = [] plt.rcParams["font.family"] = "Times New Roman" with sqlite3.connect('negativec_zero_cols_2.db') as conn: c = conn.cursor() query = '''select distinct primary_parameters.pnum from primary_parameters order by pnum;''' c.execute(query) query_result = c.fetchall() sigma = list(query_result) query = '''select primary_parameters.pnum, secondary_parameters.Ftotal from primary_parameters inner join secondary_parameters on primary_parameters.secondary_id=secondary_parameters.id;''' c.execute(query) query_result = c.fetchall() with open('box20x20.msh') as msh: get_line = lambda msh=msh: msh.readline().strip() while get_line() != '$Nodes': pass num_of_nodes = int(get_line()) nodes = [get_line().split(' ') for i in range(num_of_nodes)] node_coords = {n[0].strip() : n[1:] for n in nodes} node_numbers_energies = [(str(v[0]),v[1]) for v in query_result] node_coords_energies = [(float(node_coords[n[0]][0]), float(node_coords[n[0]][1]), n[1]) for n in node_numbers_energies] x = np.array([n[0] for n in node_coords_energies]) y = np.array([n[1] for n in node_coords_energies]) z = np.array([n[2] for n in node_coords_energies]) enmean = np.sum(z) / z.size z = (z - enmean) / enmean zfull = z.max() - z.min() zlow = z.min() + zfull*0.0 zhigh = z.max() - zfull*0.5 zmin = z.min() zmax = z.max() triang = tri.Triangulation(x, y) refiner = tri.UniformTriRefiner(triang) tri_refi, z_refi = refiner.refine_field(z, subdiv=3) coordinates = extractor_str.get_coords('unscos_pview/') sigmas = np.loadtxt('B10Q') polars = np.loadtxt('B10P') fieldv = sigmas[:len(coordinates)] field_min = fieldv.min() field_max = fieldv.max() for i,pack in enumerate(zip(coordinates[:], fieldv[:])): c, fv = pack coord = [(x,y,z) for x,y,z in zip(c[0][0::5], c[1][0::5], c[2][0::5])] x1 = np.array([v[0] for v in coord]) y1 = np.array([v[1] for v in coord]) z1 = np.array([v[2] for v in coord]) z1 = (z1 - z1.min()) / (z1.max() - z1.min()) fig = plt.figure(figsize=(12,11)) spec = gridspec.GridSpec(ncols=2, nrows=1, wspace=0.1, hspace=0.1, width_ratios=[9, 0.5]) mainplot = fig.add_subplot(spec[:, 0]) energyplot = fig.add_subplot(spec[:, 1]) from matplotlib.colors import LinearSegmentedColormap colors = [(0.0, 0.0, 1.0), (0.0, 1.0, 0.0), (1.0, 0.0, 0.0)] cmap_name = 'domwall_map' mycm = LinearSegmentedColormap.from_list(cmap_name, colors, N=13) cf = mainplot.tricontourf(tri_refi, z_refi, cmap=cm.seismic, levels=np.linspace(zlow, zhigh, 271, endpoint=True)) cf_ = mainplot.tricontourf(x1, y1, z1, cmap=mycm, alpha=0.4, levels=[0.0, 0.35, 0.65, 1.0]) from matplotlib.collections import PatchCollection from matplotlib.patches import Rectangle rect = Rectangle((-50, 0), 100, fv) pc = PatchCollection([rect]) energyplot.add_collection(pc) x0m,x1m = mainplot.get_xlim() y0m,y1m = mainplot.get_ylim() mainplot.set_aspect(abs(x1m-x0m)/abs(y1m-y0m)) mainplot.set(xlabel=r'Side length (nm)', ylabel=r'Side length (nm)') energyplot.set_xlim(0,1) energyplot.set_ylim(field_min, field_max) energyplot.set_xticks([]) energyplot.tick_params(axis='y', left=False, right=True, labelleft=False, labelright=True) energyplot.yaxis.set_label_position('right') energyplot.set(ylabel=r'Surface charge, Q/S (C/m$^{2}$)') divider = make_axes_locatable(mainplot) cax = divider.new_vertical(size="5%", pad=0.9, pack_start=True) fig.add_axes(cax) cb = fig.colorbar(cf, cax=cax, orientation="horizontal", label='Normalized domain wall pinning relief', ticks=[zlow + (zhigh-zlow)/5*i for i in range(6)], format=matplotlib.ticker.FuncFormatter(lambda x, p: '{:.2f}'.format(x*1000))) cf.set_clim(zlow, zhigh) plt.figtext(0.25, 0.9, 'Domain wall displacement as a responce\n to the charge at the electrodes', fontsize=24) plt.figtext(0.78, 0.1175, 'x 10$^{-3}$', fontsize=20) for axv in [mainplot, energyplot, cax]: for item in ([axv.title, axv.xaxis.label, axv.yaxis.label]): item.set_fontsize(24) for item in (axv.get_xticklabels() + axv.get_yticklabels()): item.set_fontsize(20) fig.tight_layout() plt.savefig('{}.png'.format(i)) plt.close()
def plot_asymmetries_3_dimensions(dist, title=None, nlevels=200, subdiv=4): # define the simplex (an equilateral triangle with vertices (0,1), (1,0), and (0.5, 0.5 * tan(60 degrees) corners = np.array([[0, 0], [1, 0], [0.5, 0.5 * np.tan(np.pi / 3)]]) triangle = tri.Triangulation(corners[:, 0], corners[:, 1]) # compute the cartesian coordinates for the midpoint of each side midpoints = [(corners[(i + 1) % 3] + corners[(i + 2) % 3]) / 2.0 for i in range(3)] def cartesian_to_barycentric(xy, tol=1.e-3): # convert Cartesian coordinates to Barycentric s = np.array([(corners[i] - midpoints[i]).dot(xy - midpoints[i]) / 0.75 for i in range(3)]) # ensure we are not to close to 0 or 1 for numerical reasons s[s < tol] = tol s[s > 1 - tol] = 1 - tol # normalize the clipped result s /= np.sum(s) return s # set evaluation points refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=subdiv) # convert to Barycentric coordinates pi = np.array( [cartesian_to_barycentric(xy) for xy in zip(trimesh.x, trimesh.y)]) # construct the figure rows = 4 cols = 8 fig, ax = plt.subplots(rows, cols, figsize=(8, 5)) ax = np.reshape(ax, -1) i_plot = 0 # set the color map cmap = 'jet' # plot the expected (symmetric under uniform permutations) distribution e_f = [dist.pdf(pi, order=-2) for pi in pi] ax[i_plot].tricontourf(trimesh, e_f, nlevels, vmin=0, cmap=cmap) ax[i_plot].set_title('$E[f]$', fontsize=FONT_SIZE_SP_TITLE) ax[i_plot].set_ylabel('PDF', fontsize=FONT_SIZE_AXIS_LABEL) i_plot += 1 # plot the approximate expected (symmetric under uniform permutations) distribution e_f = [dist.pdf(pi, order=-1) for pi in pi] ax[i_plot].tricontourf(trimesh, e_f, nlevels, vmin=0, cmap=cmap) ax[i_plot].set_title('$\\hat{E}[f]$', fontsize=FONT_SIZE_SP_TITLE) i_plot += 1 # loop over the pdf's associated with each stick-breaking order f = [] for i in range(len(dist.f)): # evaluate the probabilities f.append([dist.pdf(pi, order=i) for pi in pi]) # get the ordering order = ''.join([str(o + 1) for o in dist.perms[i]]) # plot the data ax[i_plot].tricontourf(trimesh, f[-1], nlevels, vmin=0, cmap=cmap) ax[i_plot].set_title('$f_{' + order + '}$', fontsize=FONT_SIZE_SP_TITLE) i_plot += 1 # define possible symmetries axes = {0, 1, 2} symmetries = [[1, 2], [0, 2], [0, 1]] # loop over the symmetries asymmetries = [] barycentric_axes = [] for symmetry in symmetries: # loop over the orders for order in range(-2, len(f)): # collect asymmetries and its axis asymmetries.append(get_asymmetry(dist, order, pi, symmetry)) barycentric_axes.extend(list(axes - set(symmetry))) # loop over the asymmetries for asymmetry, axis in zip(asymmetries, barycentric_axes): # plot anti-symmetric portion ax[i_plot].tricontourf(trimesh, asymmetry, nlevels, vmin=0, vmax=np.max(asymmetries), cmap=cmap) if np.mod(i_plot, cols) == 0: ax[i_plot].set_ylabel('$x_{' + str(axis + 1) + '}$ Asym.', fontsize=FONT_SIZE_AXIS_LABEL) i_plot += 1 # make it pretty for i in range(len(ax)): ax[i].axis('equal') ax[i].set_xlim(0, 1) ax[i].set_ylim(0, 0.75**0.5) ax[i].set_xticks([]) ax[i].set_yticks([]) ax[i].spines['top'].set_visible(False) ax[i].spines['right'].set_visible(False) ax[i].spines['bottom'].set_visible(False) ax[i].spines['left'].set_visible(False) # add the title if one is provided if title is not None: fig.suptitle(title, fontsize=FONT_SIZE_FIG_TITLE) # make it tight plt.subplots_adjust(left=0.04, bottom=0, right=1, top=0.85, wspace=0, hspace=0)
# 3D example! Woo! n_dim = 3 B3 = 1.0 # 256.0 # aa3 = np.array([1.0, 0.2, 0.5]) # np.random.uniform(size=n_dim) # bb3 = np.array([2.0, 10.0, 4.0]) #np.random.uniform(size=n_dim) # tt3 = np.zeros(n_dim) lgs3 = LagrangeSolver(aa3, bb3, tt3, B3) simplex_corners = np.array([[0, 0], [1, 0], [0.5, 0.75**0.5]]) tri_object = tri.Triangulation(simplex_corners[:, 0], simplex_corners[:, 1]) refiner = tri.UniformTriRefiner(tri_object) simplex_mesh = refiner.refine_triangulation(subdiv=6) def simplex2cart(a, b, c): x = .5 * (2 * b + c) y = np.sqrt(3) / 2 * c return x, y def cart2simplex(x, y): c = y * 2 / np.sqrt(3) b = x - c / 2 a = 1 - b - c return a, b, c
}, }, open('limits.json', 'w'), indent=2) writer.writerows(lines) # Center and scale x_points = np.array(x_data) - np.mean(x_data) y_points = np.array(y_data) - np.mean(y_data) z_points = np.array(z_data) # make delaunai triangulation triangulation = tri.Triangulation(x_points, y_points) refiner = tri.UniformTriRefiner(triangulation) tri_refi, z_test_refi = refiner.refine_field(z_points, subdiv=3) plt.gca().set_aspect('equal') plt.triplot(triangulation, lw=1, color='gray') levels = np.arange(int(min(z_data)), int(max(z_data)), 1) cmap = cm.get_cmap(name='bone', lut=None) # plt.tricontourf(tri_refi, z_test_refi, levels=levels, cmap=cmap) plt.tricontour( tri_refi, z_test_refi, levels=levels, colors=['0.25', '0.5', '0.5', '0.5', '0.5'], linewidths=[1.0, 0.5, 0.5, 0.5, 0.5], )
def draw_func_contours(func, labels=None, nlevels=200, subdiv=8, fig=None, ax=None, grid=True, **kwargs): ''' Parameters: ----------- labels: None, string or list of strings If labels == 'auto' it shows the class number on each corner If labels is a list of strings it shows each string in the corresponding corner If None does not show any label ''' corners = np.array([[0, 0], [1, 0], [0.5, 0.75**0.5]]) triangle = tri.Triangulation(corners[:, 0], corners[:, 1]) refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=subdiv) pvals = np.array([func(xy2bc(xy)) for xy in zip(trimesh.x, trimesh.y)]) if fig is None: fig = plt.figure() if ax is None: ax = fig.add_subplot(111) # FIXME I would like the following line to work, but the max value is not # shown. I had to do create manually the levels and increase the max value # by an epsilon. This could be a major problem if the epsilon is not small # for the original range of values # contour = ax.tricontourf(trimesh, pvals, nlevels, **kwargs) # contour = ax.tricontourf(trimesh, pvals, nlevels, extend='both') contour = ax.tricontourf(trimesh, pvals, levels=np.linspace(pvals.min(), pvals.max() + 1e-9, nlevels), **kwargs) # Colorbar cb = fig.colorbar(contour, ax=ax, fraction=0.1, orientation='horizontal') tick_locator = ticker.MaxNLocator(nbins=5) cb.locator = tick_locator # cb.ax.xaxis.set_major_locator(ticker.AutoLocator()) cb.update_ticks() if labels is not None: if labels == 'auto': labels = [r'$C_{}$'.format(i + 1) for i in range(len(corners))] center = corners.mean(axis=0) for i, corner in enumerate(corners): text_x, text_y = corner - (center - corner) * 0.1 ax.text(text_x, text_y, labels[i], verticalalignment='center', horizontalalignment='center') triangle = tri.Triangulation(corners[:, 0], corners[:, 1]) if grid: refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=4) ax.triplot(trimesh, c='gray', lw=0.2) ax.triplot(triangle, c='k', lw=0.8) # Axes options ax.set_xlim(xmin=0, xmax=1) ax.set_ylim(ymin=0, ymax=0.75**0.5) ax.set_xbound(lower=0, upper=1) ax.set_ybound(lower=0, upper=0.75**0.5) ax.axis('equal') ax.axis('off') plt.gca().set_adjustable("box")
def test_tri_smooth_gradient(): # Image comparison based on example trigradient_demo. def dipole_potential(x, y): """ An electric dipole potential V """ r_sq = x**2 + y**2 theta = np.arctan2(y, x) z = np.cos(theta) / r_sq return (np.max(z) - z) / (np.max(z) - np.min(z)) # Creating a Triangulation n_angles = 30 n_radii = 10 min_radius = 0.2 radii = np.linspace(min_radius, 0.95, n_radii) angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False) angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1) angles[:, 1::2] += np.pi / n_angles x = (radii * np.cos(angles)).flatten() y = (radii * np.sin(angles)).flatten() V = dipole_potential(x, y) triang = mtri.Triangulation(x, y) xmid = x[triang.triangles].mean(axis=1) ymid = y[triang.triangles].mean(axis=1) mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0) triang.set_mask(mask) # Refine data - interpolates the electrical potential V refiner = mtri.UniformTriRefiner(triang) tri_refi, z_test_refi = refiner.refine_field(V, subdiv=3) # Computes the electrical field (Ex, Ey) as gradient of -V tci = mtri.CubicTriInterpolator(triang, -V) (Ex, Ey) = tci.gradient(triang.x, triang.y) E_norm = np.sqrt(Ex**2 + Ey**2) # Plot the triangulation, the potential iso-contours and the vector field plt.figure() plt.gca().set_aspect('equal') plt.triplot(triang, color='0.8') levels = np.arange(0., 1., 0.01) cmap = cm.get_cmap(name='hot', lut=None) plt.tricontour(tri_refi, z_test_refi, levels=levels, cmap=cmap, linewidths=[2.0, 1.0, 1.0, 1.0]) # Plots direction of the electrical vector field plt.quiver(triang.x, triang.y, Ex / E_norm, Ey / E_norm, units='xy', scale=10., zorder=3, color='blue', width=0.007, headwidth=3., headlength=4.) plt.show()
def plot_ternary(distribute_func, n_levels=200, subdiv=8, **kwargs): corners = np.array([[0, 0], [1, 0], [0.5, 0.75**0.5]]) # cos(30) triangle = tri.Triangulation(corners[:, 0], corners[:, 1]) # Mid-points of triangle sides opposite of each corner RI = np.linalg.inv(np.vstack((corners.T, [1, 1, 1]))) def xy2bc(xys, tol=1.e-3): ''' Converts 2D Cartesian coordinates to barycentric. according to https://en.wikipedia.org/wiki/Barycentric_coordinate_system#Conversion_between_barycentric_and_Cartesian_coordinates''' xysT = np.transpose(xys) ones = [1] * len(xys) xysT1 = np.vstack((xysT, ones)) lambda_ = RI.dot(xysT1).T return np.clip(lambda_, a_min=tol, a_max=1.0 - tol) def tick_labels(scale=100, size=20): return [ str(int(i)) for i in np.arange(0, scale / size * (size + 1), scale / size) ] def tick_txy(location, width=1.0, size=20): height = width * 0.75**0.5 if location == 'left': xy = np.array(( np.arange(0, width / 2 / size * (size + 1), width / 2 / size), np.arange(0, height / size * (size + 1), height / size), )) return xy[0, :][::-1], xy[1, :][::-1] if location == 'right': xy = np.array(( np.arange(0.5, 0.5 + width / 2 / size * (size + 1), width / 2 / size), np.arange(0, height / size * (size + 1), height / size), )) return xy[0, :][::-1], xy[1, :] if location == 'bottom': xy = np.array(( np.arange(0, width / size * (size + 1), width / size), np.array((0.0, ) * (size + 1)), )) return xy[0, :], xy[1, :] refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=subdiv) bc = xy2bc(list(zip(trimesh.x, trimesh.y))) pvals = distribute_func(bc) fig = plt.figure() ax = fig.add_subplot(111, aspect='equal') ax.triplot(triangle, color='black') trimap = ax.tricontourf(trimesh, pvals, n_levels, **kwargs) # trimap = ax.tricontourf(x,y,t,n_levels,**kwargs) offset = 0.02 linewidth = 1. for x, y, s in zip(*tick_txy('left'), tick_labels()): ax.text(x - offset / 2, y + 0.75**0.5 * offset, s, verticalalignment='center', horizontalalignment='right') ax.plot((x, x - offset / 2), (y, y + 0.75**0.5 * offset), '-', lw=linewidth, color='black') for x, y, s in zip(*tick_txy('right'), tick_labels()): ax.text(x + offset / 2, y, s, verticalalignment='center', horizontalalignment='left') ax.plot((x, x + offset / 2), (y, y), '-', lw=linewidth, color='black') for x, y, s in zip(*tick_txy('bottom'), tick_labels()): ax.text(x - offset / 2, y - 0.75**0.5 * offset, s, verticalalignment='top', horizontalalignment='center') ax.plot((x, x - offset / 2), (y, y - 0.75**0.5 * offset), '-', lw=linewidth, color='black') ''' from mpl_toolkits.axes_grid1 import make_axes_locatable divider = make_axes_locatable(plt.gca()) cax = divider.append_axes("right", "5%", pad="-8%") fig.colorbar(trimap, cax=cax) ''' fig.colorbar(trimap) ax.set_aspect('equal') fig.tight_layout(pad=0) ax.axis('equal') # ax.set_xlim(0, 1) # ax.set_ylim(-0.02, 0.75**0.5+0.02) ax.axis('off') return fig
def contour_plot(local_to_global, nodes_to_coordinates, u_h): x = nodes_to_coordinates[:, 0] #.transpose() y = nodes_to_coordinates[:, 1] #.transpose() triangulation = tri.Triangulation(x, y, local_to_global) N_fe = local_to_global.shape[0] u_max = u_h.max() u_min = u_h.min() umin2 = u_min - 0.05 * abs(u_max - u_min) umax2 = u_max + 0.05 * abs(u_max - u_min) levels = np.arange(u_min - 0.05 * abs(u_max - u_min), u_max + 0.05 * abs(u_max - u_min), abs(u_max - u_min) / 25.) #levels = np.arange(-1.1, 1.1, 0.1) fig = plt.figure() ax = fig.add_axes([0.1, 0.1, 0.7, 0.8]) ax.set_xlim((-1, 1)) #fix constants ax.set_ylim((-1, 1)) for r in range(0, N_fe): i1 = local_to_global[r, 0] i2 = local_to_global[r, 1] i3 = local_to_global[r, 2] x1 = nodes_to_coordinates[i1, 0] x2 = nodes_to_coordinates[i2, 0] x3 = nodes_to_coordinates[i3, 0] y1 = nodes_to_coordinates[i1, 1] y2 = nodes_to_coordinates[i2, 1] y3 = nodes_to_coordinates[i3, 1] t = tri.Triangulation(x[[i1, i2, i3]], y[[i1, i2, i3]]) r = tri.UniformTriRefiner(t) # zX = t.x.copy() # zX[0] = u_h[i1] # zX[1] = u_h[i2] # zX[2] = u_h[i3] #zX = np.array([u_h[i1],u_h[i2],u_h[i3]]) #print(t.x) #print(zX) refi_t = r.refine_triangulation(subdiv=2) rx = refi_t.x.copy() ry = refi_t.y.copy() detJ = x2 * y3 - x2 * y1 - x1 * y3 - x3 * y2 + x3 * y1 + x1 * y2 rx2 = rx.copy() ry2 = ry.copy() for i in range(0, rx.shape[0]): #buggy? rx[i] = (y3 - y1) * (rx2[i] - x1) + (-x3 + x1) * (ry2[i] - y1) ry[i] = (-y2 + y1) * (rx2[i] - x1) + (x2 - x1) * (ry2[i] - y1) rx = 1. / detJ * rx ry = 1. / detJ * ry #local functions phi1 = 1 - rx - ry phi2 = rx phi3 = ry #print('rx = '+ str(rx)) #print('ry = '+ str(ry)) #add weights phi = u_h[i1] * phi1 + u_h[i2] * phi2 + u_h[i3] * phi3 #print(phi) r2 = tri.UniformTriRefiner(refi_t) t2, z2 = r2.refine_field(phi, subdiv=3) #ax.tricontourf(t2, z2, cmap='cool', levels=levels) #t2, z2 = r.refine_field(zX, subdiv=2) ax.tricontour(t2, z2, cmap='cool', levels=levels) #plt.triplot(refi_t, color='g') ax.triplot(triangulation, color='0.5', lw=0.2) #ax2 = fig.add_axes([0.82, 0.1, 0.85, 0.8]) ax2 = fig.add_axes([0.85, 0.1, 0.02, 0.8]) norm = matplotlib.colors.Normalize(vmin=umin2, vmax=umax2) cb1 = matplotlib.colorbar.ColorbarBase(ax2, cmap='cool', norm=norm, orientation='vertical') plt.savefig('images/tri_sol.png', dpi=300) pass
def __init__(self, order=2): self.order = order x = np.asarray([-1, 1, -1]) y = np.asarray([-1, -1, 1]) tri = mtri.Triangulation(x, y) refiner = mtri.UniformTriRefiner(tri) fine_tri = refiner.refine_triangulation(subdiv=9) xi_1 = fine_tri.x xi_2 = fine_tri.y lamda = np.zeros((3, len(xi_1))) dlamda = [np.zeros((3, len(xi_1))), np.zeros((3, len(xi_1)))] lamda[0, :] = (xi_2 + 1.) / 2. dlamda[1][0, :] = 1. / 2. lamda[1, :] = -(xi_1 + xi_2) / 2. dlamda[0][1, :] = -1. / 2. dlamda[1][1, :] = -1. / 2. lamda[2, :] = (xi_1 + 1.) / 2. dlamda[0][2, :] = 1. / 2. # Number of Shape Functions self.nb_v = 3 self.nb_e = 3 * (order - 1) self.nb_f = int(((order - 1) * (order - 2)) / 2) self.nb_SF = self.nb_v + self.nb_e + self.nb_f # Initialisation of Shape Functions and derivatives self.Phi = np.zeros((self.nb_SF, len(xi_1))) self.dPhi = [ np.zeros((self.nb_SF, len(xi_1))), np.zeros((self.nb_SF, len(xi_1))) ] # Vertices Shape Functions self.Phi[0, :], self.Phi[1, :], self.Phi[2, :] = lamda[1, :], lamda[ 2, :], lamda[0, :] for _xi in range(2): self.dPhi[_xi][0, :], self.dPhi[_xi][1, :], self.dPhi[_xi][ 2, :] = dlamda[_xi][1, :], dlamda[_xi][2, :], dlamda[_xi][0, :] # Edge Shape Functions for _o in range(order - 1): _index_edge = [ 3 + _o, 3 + (order - 1) + _o, 3 + 2 * (order - 1) + _o ] for i_e in range(3): self.Phi[_index_edge[i_e], :] = lamda[ (i_e + 1) % 3, :] * lamda[(i_e + 2) % 3, :] * phi( _o, lamda[(i_e + 2) % 3, :] - lamda[(i_e + 1) % 3, :])[0] for _xi in range(2): self.dPhi[_xi][_index_edge[i_e], :] += dlamda[_xi][ (i_e + 1) % 3, :] * lamda[(i_e + 2) % 3, :] * phi( _o, lamda[(i_e + 2) % 3, :] - lamda[(i_e + 1) % 3, :])[0] self.dPhi[_xi][_index_edge[i_e], :] += dlamda[_xi][ (i_e + 2) % 3, :] * lamda[(i_e + 1) % 3, :] * phi( _o, lamda[(i_e + 2) % 3, :] - lamda[(i_e + 1) % 3, :])[0] self.dPhi[_xi][_index_edge[i_e], :] += lamda[ (i_e + 1) % 3, :] * lamda[(i_e + 2) % 3, :] * phi( _o, lamda[(i_e + 2) % 3, :] - lamda[(i_e + 1) % 3, :])[1] * ( dlamda[_xi][(i_e + 2) % 3, :] - dlamda[_xi][(i_e + 1) % 3, :]) # Face Shape Functions _index = self.nb_v + self.nb_e for n_1 in range(1, order - 1): for n_2 in range(1, n_1 + 1): self.Phi[ _index, :] = lamda[0, :] * lamda[1, :] * lamda[2, :] * phi( n_1 - 1, lamda[2, :] - lamda[1, :])[0] * phi( n_2 - 1, lamda[1, :] - lamda[0, :])[0] for _xi in range(2): self.dPhi[_xi][_index, :] += dlamda[_xi][ 0, :] * lamda[1, :] * lamda[2, :] * phi( n_1 - 1, lamda[2, :] - lamda[1, :])[0] * phi( n_2 - 1, lamda[1, :] - lamda[0, :])[0] self.dPhi[_xi][_index, :] += dlamda[_xi][ 1, :] * lamda[0, :] * lamda[2, :] * phi( n_1 - 1, lamda[2, :] - lamda[1, :])[0] * phi( n_2 - 1, lamda[1, :] - lamda[0, :])[0] self.dPhi[_xi][_index, :] += dlamda[_xi][ 2, :] * lamda[1, :] * lamda[0, :] * phi( n_1 - 1, lamda[2, :] - lamda[1, :])[0] * phi( n_2 - 1, lamda[1, :] - lamda[0, :])[0] self.dPhi[_xi][_index, :] += lamda[ 0, :] * lamda[1, :] * lamda[2, :] * phi( n_1 - 1, lamda[2, :] - lamda[1, :])[1] * ( dlamda[_xi][2, :] - dlamda[_xi][1, :]) * phi( n_2 - 1, lamda[1, :] - lamda[0, :])[0] self.dPhi[_xi][_index, :] += lamda[ 0, :] * lamda[1, :] * lamda[2, :] * phi( n_2 - 1, lamda[1, :] - lamda[0, :])[1] * ( dlamda[_xi][1, :] - dlamda[_xi][0, :]) * phi( n_1 - 1, lamda[2, :] - lamda[1, :])[0] _index += 1 i_SF = 14 plt.figure() plt.tricontourf(fine_tri, self.Phi[i_SF, :], cmap=cm.jet, levels=10) plt.colorbar() plt.show()
def plot2dHeatMap(BrutX, BrutY, BrutZ, QuantityTitle, filename, ShowFinalPlot=True): #{{{ Header = "[plot2dHeatMap: ]" #print len(BrutX) #print len(BrutY) #print len(BrutZ) X = list(set(BrutX)) Y = list(BrutY) #Z=DensityMax2Dsorted YY, XX = np.meshgrid(X, Y) # If the size is big enough, let's make a plot. #if(len(DensityMax2D) >= 2): #{{{ if (len(BrutZ) >= 2): #{{{ ##try: triang = tri.Triangulation(BrutX, BrutY) triang.set_mask( np.hypot(BrutX[triang.triangles].mean( axis=1), BrutY[triang.triangles].mean(axis=1)) < 0.000000015) refiner = tri.UniformTriRefiner(triang) tri_refi, z_test_refi = refiner.refine_field(BrutZ, subdiv=3) #plt.figure() #plt.title(r'$N_{exc}(E_1,E_2)$, $\lambda_1=$'+str(wavelength1*1E9)+r'nm, $\lambda_2=$'+str(wavelength2*1E9)+'nm.') fig = plt.figure() #ax = fig.add_subplot(111) #, projection='3d') ##plt.gca().set_aspect('equal') plt.title(QuantityTitle) ##plt.xlabel(r'$E_1$ (V/nm)') ##plt.ylabel(r'$E_2$ (V/nm)') ##CS = plt.imshow(XX, YY, DensityMax2Dsorted) #, cmap=plt.cm.Blues) ##CS = plt.contourf(XX, YY, DensityMax2Dsorted, cmap=plt.cm.Blues) ##CS = ax.plot_wireframe(XX, YY, DensityMax2Dsorted) #, cmap=plt.cm.Blues) #FAILS: WHY do we have ground values ?! ##CS = ax.plot_surface(XX, YY, DensityMax2DsortedShape) #, cmap=plt.cm.Blues) #FAILS: WHY do we have ground values ?! #CS = ax.scatter(BrutX, BrutY, BrutZ) #, cmap=plt.cm.Blues) #WORKS but limited to boring dots #CS = ax.plot_trisurf(BrutX, BrutY, BrutZ, cmap=plt.cm.Blues, antialiased=True, edgecolor='none') #WORKS ##ax.view_init(90, 90) ##See https://matplotlib.org/gallery/images_contours_and_fields/tricontour_smooth_user.html#sphx-glr-gallery-images-contours-and-fields-tricontour-smooth-user-py plt.triplot(triang, lw=0.1, color='grey') #levels = np.linspace(np.min(BrutZ), np.max(BrutZ), 10) levels = np.linspace(0, 100, 10) #cmap = cm.get_cmap(name='terrain', lut=None) #cmap = cm.get_cmap(name='Blues', lut=None) cmap = cm.get_cmap(name='BuPu', lut=None) plt.tricontourf(tri_refi, z_test_refi, levels=levels, cmap=cmap) #plt.tricontour(tri_refi, z_test_refi, levels=levels, ##colors=['0.25', '0.5', '0.5', '0.5', '0.5'], ##linewidths=[1.0, 0.5, 0.5, 0.5, 0.5]) plt.colorbar() plt.tight_layout() #except: #CS = -1 #print Header+"** Warning: failed to produce one of the plots." #print np.shape(BrutX), np.shape(BrutY), np.shape(BrutZ) #print np.shape(Xi), np.shape(Yi) #print np.shape(XXi), np.shape(YYi) #print np.shape(BicolorNeFinal) #CS = ax.scatter(XXi, YYi, BicolorNeFinal) #, cmap=plt.cm.Blues) #WORKS #CS = ax.plot_trisurf(Xi, Yi, BicolorNeFinal, cmap=plt.cm.Spectral) #CS = ax.contour(XX, YY, Z, cmap=plt.cm.Blues) #WORKS #plt.colorbar(CS) plt.savefig(filename + '.eps') plt.savefig(filename + '.png') print(Header, "** Info: saved ", filename, "png|eps.") if (ShowFinalPlot): plt.show()
class simplex_dynamics: '''draws dynamics of given function and corresponding fixed points into triangle''' #corners of triangle and calculation of points r0 = np.array([0, 0]) r1 = np.array([1, 0]) r2 = np.array([1 / 2., np.sqrt(3) / 2.]) corners = np.array([r0, r1, r2]) triangle = tri.Triangulation(corners[:, 0], corners[:, 1]) refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=5) trimesh_fine = refiner.refine_triangulation(subdiv=5) def __init__(self, fun): self.f = fun self.calculate_stationary_points() self.calc_direction_and_strength() #barycentric coordinates def xy2ba(self, x, y): corner_x = self.corners.T[0] corner_y = self.corners.T[1] x_1 = corner_x[0] x_2 = corner_x[1] x_3 = corner_x[2] y_1 = corner_y[0] y_2 = corner_y[1] y_3 = corner_y[2] l1 = ((y_2 - y_3) * (x - x_3) + (x_3 - x_2) * (y - y_3)) / ((y_2 - y_3) * (x_1 - x_3) + (x_3 - x_2) * (y_1 - y_3)) l2 = ((y_3 - y_1) * (x - x_3) + (x_1 - x_3) * (y - y_3)) / ((y_2 - y_3) * (x_1 - x_3) + (x_3 - x_2) * (y_1 - y_3)) l3 = 1 - l1 - l2 return np.array([l1, l2, l3]) def ba2xy(self, x): ### x: array of 3-dim ba coordinates ### corners: coordinates of corners of ba coordinate system x = np.array(x) # print(self.corners.shape) # print(self.corners.T) # print(x) return self.corners.T.dot(x.T).T def calculate_stationary_points(self): fp_raw = [] border = 5 #don't check points close to simplex border delta = 1e-12 for x, y in zip(self.trimesh.x[border:-border], self.trimesh.y[border:-border]): start = self.xy2ba(x, y) fp_try = np.array([]) sol = scipy.optimize.root( self.f, start, args=(0, ), method="hybr") #,xtol=1.49012e-10,maxfev=1000 if sol.success: fp_try = sol.x #check if FP is in simplex if not math.isclose(np.sum(fp_try), 1., abs_tol=2.e-3): continue if not np.all((fp_try > -delta) & (fp_try < 1 + delta)): #only if fp in simplex continue else: continue #only add new fixed points to list if not np.array( [np.allclose(fp_try, x, atol=1e-7) for x in fp_raw]).any(): fp_raw.append(fp_try.tolist()) #add fixed points in correct coordinates to fixpoints list fp_raw = np.array(fp_raw) if fp_raw.shape[0] > 0: self.fixpoints = self.corners.T.dot(np.array(fp_raw).T).T else: self.fixpoints = np.array([]) def calc_direction_and_strength(self): direction = [ self.f(self.xy2ba(x, y), 0) for x, y in zip(self.trimesh.x, self.trimesh.y) ] self.direction_norm = np.array([ self.ba2xy(v) / np.linalg.norm(v) if np.linalg.norm(v) > 0 else np.array([0, 0]) for v in direction ]) self.direction_norm = self.direction_norm #print(direction_ba_norm) self.pvals = [np.linalg.norm(v) for v in direction] self.direction = np.array([self.ba2xy(v) for v in direction]) def plot_simplex(self, ax, cmap='viridis', typelabels=["A", "B", "C"], **kwargs): ax.triplot(self.triangle, linewidth=0.8, color="black") ax.tricontourf(self.trimesh, self.pvals, alpha=0.8, cmap=cmap, **kwargs) #arrow plot options: # Q = ax.quiver(self.trimesh.x, self.trimesh.y, self.direction_norm.T[0],self.direction_norm.T[1],self.pvals,angles='xy',pivot='mid', cmap=cmap)#pivot='tail', Q = ax.quiver(self.trimesh.x, self.trimesh.y, self.direction_norm.T[0], self.direction_norm.T[1], angles='xy', pivot='mid') #pivot='tail')# # Q = ax.quiver(self.trimesh.x, self.trimesh.y, self.direction.T[0],self.direction.T[1],angles='xy',pivot='mid')#pivot='tail')# ax.axis('equal') ax.axis('off') margin = 0.01 ax.set_ylim(ymin=-margin, ymax=self.r2[1] + margin) ax.set_xlim(xmin=-margin, xmax=1. + margin) #timescatter=ax.scatter(points[::5,0],points[::5,1],c=t[::5],linewidth=0.0,cmap='viridis',alpha=.5) if self.fixpoints.shape[0] > 0: ax.scatter(self.fixpoints[:, 0], self.fixpoints[:, 1], facecolors='none', edgecolors='black', s=70, linewidth=0.3) #fig.colorbar(timescatter,label="time") ax.annotate(typelabels[0], (0, 0), xytext=(-0.0, -0.02), horizontalalignment='center', va='top') ax.annotate(typelabels[1], (1, 0), xytext=(1.0, -0.02), horizontalalignment='center', va='top') ax.annotate(typelabels[2], self.corners[2], xytext=self.corners[2] + np.array([0.0, 0.02]), horizontalalignment='center', va='bottom')
def ternary_plot(data_fn): reader = pd.read_csv(data_fn) SQRT3 = numpy.sqrt(3) SQRT3OVER2 = SQRT3 / 2. def unzip(l): return zip(*l) def permute_point(p, permutation=None): if not permutation: return p return [p[int(permutation[i])] for i in range(len(p))] def project_point(p, permutation=None): permuted = permute_point(p, permutation=permutation) a = permuted[0] b = permuted[1] x = a + b / 2. y = SQRT3OVER2 * b return numpy.array([x, y]) def project_sequence(s, permutation=None): xs, ys = unzip([project_point(p, permutation=permutation) for p in s]) return xs, ys data = [] for i, (a, b, c) in reader.iterrows(): a_ = a / (a + b + c) b_ = b / (a + b + c) c_ = c / (a + b + c) data.append((a_, b_, c_)) xs, ys = project_sequence(data) vs = (1, 2, 3) fig = plt.figure(num=None, figsize=(10, 6), dpi=80, facecolor='w', edgecolor='k') corners = numpy.array([[0, 0], [1, 0], [0.5, numpy.sqrt(3) * 0.5 * 1]]) triangle = tri.Triangulation(corners[:, 0], corners[:, 1]) # creating the grid refiner = tri.UniformTriRefiner(triangle) trimesh = refiner.refine_triangulation(subdiv=4) #plotting the colorbar colormap = plt.cm.get_cmap('Reds') #plotting the mesh plt.triplot(trimesh, '', color='0.9', zorder=1) #plotting the points plt.scatter(xs, ys, c=vs, s=100, zorder=10, cmap=colormap) for i in range(len(xs)): plt.text(xs[i] + 0.001, ys[i] + 0.001, 'Samp-' + str(i)) plt.tricontourf(xs, ys, triangle.triangles, vs) #plotting the axes plt.plot([corners[0][0], corners[1][0]], [corners[0][1], corners[1][1]], color='0.7', linestyle='-', linewidth=2) plt.plot([corners[0][0], corners[2][0]], [corners[0][1], corners[2][1]], color='0.7', linestyle='-', linewidth=2) plt.plot([corners[1][0], corners[2][0]], [corners[1][1], corners[2][1]], color='0.7', linestyle='-', linewidth=2) def plot_ticks(start, stop, tick, n): r = numpy.linspace(0, 1, num=10) xs = start[0] * (1 - r) + stop[0] * r xs = numpy.vstack((xs, xs + tick[0])) ys = start[1] * (1 - r) + stop[1] * r ys = numpy.vstack((ys, ys + tick[1])) for i in range(0, len(xs.tolist()[1])): x = xs.tolist()[1][i] y = ys.tolist()[1][i] plt.text(x, y, i, ha='center') plt.plot(xs, ys, 'k', lw=1, color='0.7') n = 10 tick_size = 0.2 margin = 0.1 left = corners[0] right = corners[1] top = corners[2] # define vectors for ticks bottom_tick = tick_size * (right - top) / n right_tick = tick_size * (top - left) / n left_tick = tick_size * (left - right) / n # plot_ticks(left, right, bottom_tick, n) # plot_ticks(right, top, right_tick, n) # plot_ticks(left, top, left_tick, n) names = [reader[column].name for column in reader] plt.text(left[0] - 0.01, left[1], names[2], horizontalalignment='right', fontsize=15, color='b') plt.text(right[0], right[1], names[0], horizontalalignment='left', fontsize=15, color='b') plt.text(top[0], top[1], names[1], fontsize=15, color='b') plt.colorbar(label="Sample density") # # plt.savefig('chart.png') plt.show()
with helper.Timer('blup'): plt.figure() levels = np.arange(1., 4, 0.1) #x =np.array for t in my_tri.triangles: t1 = mtri.Triangulation(x[t], y[t]) z1 = f_z(x[t], y[t]) #print(z1) r1 = mtri.UniformTriRefiner(t1) # t1r, z1r = r1.refine_field(z1, subdiv=3) plt.tricontourf(t1r, z1r, cmap='cool', levels=levels) plt.tricontour(t1r, z1r, levels=levels) plt.triplot(my_tri, color='r') plt.savefig('images/tri_test.png', dpi=300) # refiner = mtri.UniformTriRefiner(my_tri) # my_tri2, index = refiner.refine_triangulation(subdiv=1, return_tri_index=True)
def pcolor_map(coordinates, data, projection='mollweide', limits=None, cmap=cm.viridis, show=True, refine=False, **kwargs): """ Plot the map projection of data points sampled on a spherical surface. The data has to be real. Notes ----- In case limits are given, all out of bounds data will be clipped to the respective limit. Parameters ---------- latitude: ndarray, double Geodetic latitude angle of the map, must be in [-pi/2, pi/2] longitude: ndarray, double Geodetic longitude angle of the map, must be in [-pi, pi] data: ndarray, double Data for each angle, must have size corresponding to the number of points given in coordinates. show : boolean, optional Wheter to show the figure or not """ tri = mtri.Triangulation(coordinates.longitude, coordinates.latitude) if refine is not None: if isinstance(refine, int): subdiv = refine else: subdiv = 2 refiner = mtri.UniformTriRefiner(tri) tri, data = refiner.refine_field( data, triinterpolator=mtri.LinearTriInterpolator(tri, data), subdiv=subdiv) fig = plt.gcf() ax = plt.axes(projection=projection) ax.set_xlabel('Longitude [$^\\circ$]') ax.set_ylabel('Latitude [$^\\circ$]') extend = 'neither' if limits is None: limits = (data.min(), data.max()) else: mask_min = data < limits[0] data[mask_min] = limits[0] mask_max = data > limits[1] data[mask_max] = limits[1] if np.any(mask_max) & np.any(mask_min): extend = 'both' elif np.any(mask_max) & ~np.any(mask_min): extend = 'max' elif ~np.any(mask_max) & np.any(mask_min): extend = 'min' cf = ax.tripcolor(tri, data, cmap=cmap, vmin=limits[0], vmax=limits[1], **kwargs) plt.grid(True) cb = fig.colorbar(cf, ax=ax, extend=extend) cb.set_label('Amplitude') if show: plt.show() return cf
z = function_z(x, y) # Now create the Triangulation. # (Creating a Triangulation without specifying the triangles results in the # Delaunay triangulation of the points.) triang = tri.Triangulation(x, y) # Mask off unwanted triangles. triang.set_mask(np.hypot(x[triang.triangles].mean(axis=1), y[triang.triangles].mean(axis=1)) < min_radius) # ----------------------------------------------------------------------------- # Refine data # ----------------------------------------------------------------------------- refiner = tri.UniformTriRefiner(triang) tri_refi, z_test_refi = refiner.refine_field(z, subdiv=3) # ----------------------------------------------------------------------------- # Plot the triangulation and the high-res iso-contours # ----------------------------------------------------------------------------- fig, ax = plt.subplots() ax.set_aspect('equal') ax.triplot(triang, lw=0.5, color='white') levels = np.arange(0., 1., 0.025) cmap = cm.get_cmap(name='terrain', lut=None) ax.tricontourf(tri_refi, z_test_refi, levels=levels, cmap=cmap) ax.tricontour(tri_refi, z_test_refi, levels=levels, colors=['0.25', '0.5', '0.5', '0.5', '0.5'], linewidths=[1.0, 0.5, 0.5, 0.5, 0.5])
# Building parametrisation of the surface s = np.zeros(np.shape(XS)[0]) t = np.zeros(np.shape(XS)[0]) begin = 0 end = 0 for g in range(np.shape(sample_data)[0]): cut = np.argwhere(XS == g).flatten() begin = end end += np.size(cut, 0) X_loc = XS[cut] Y_loc = YS[cut] Z_loc = ZS[cut] s[begin:end] = g / float(np.size(sample_data, 0)) t[begin:end] = re_ordinate(Y_loc, Z_loc) #ax.plot(X_loc, Y_loc, Z_loc, color="grey") triangles = mtri.Triangulation(s, t).triangles refiner = mtri.UniformTriRefiner(mtri.Triangulation(s, t)) subdiv = 2 _, x_refi = refiner.refine_field(XS, subdiv=subdiv) _, y_refi = refiner.refine_field(YS, subdiv=subdiv) triang_param, z_refi = refiner.refine_field(ZS, subdiv=subdiv) #triang_param = refiner.refine_triangulation()#mtri.Triangulation(XS, YS, triangles) #print triang_param.triangles triang = mtri.Triangulation(x_refi, y_refi, triang_param.triangles) ax.plot_trisurf(triang, z_refi, cmap=cm.jet, lw=0.) plt.show()