def plotstate(Mesh, U, field, fname): V = Mesh['V'] E = Mesh['E'] BE = Mesh['BE'] f = plt.figure(figsize=(12,6)) F = pu.getField(U, field) plt.tripcolor(V[:,0], V[:,1], triangles=E, facecolors=F, shading='flat', vmin=1.55, vmax=1.9) for i in range(len(BE)): x = [V[BE[i,0],0], V[BE[i,1],0]] y = [V[BE[i,0],1], V[BE[i,1],1]] plt.plot(x, y, '-', linewidth=2, color='black') #dosave = (len(fname) != 0) plt.axis('equal') #plt.axis([-100, 100,-100, 100]) plt.axis([-2, 10,-4, 4]) plt.colorbar() #plt.clim(0, 0.8) plt.title(field, fontsize=16) f.tight_layout() plt.show()#block=(not dosave)) #if (dosave): plt.savefig(fname) plt.close(f)
def draw_map(triangulation, options): ''' get the triangle tuple (concentration, triangle] prepared before and draw the map of triangles options : "map_format": "svg", "map_file": "../../mapa" ''' lab_x = options['xlabel'] if value_set(options, 'xlabel') else 'mesh X coord' lab_y = options['ylabel'] if value_set(options, 'ylabel') else 'mesh Y coord' lab_tit = options['title'] if value_set(options, 'title') else 'Map of concentrations' plt.figure() plt.gca().set_aspect('equal') plt.tripcolor(triangulation['x_np'], triangulation['y_np'], triangulation['triangles'], facecolors=triangulation['zfaces'], edgecolors='k') plt.colorbar() plt.title(lab_tit) plt.xlabel(lab_x) plt.ylabel(lab_y) plt.savefig(options["map_file"], format=options["map_format"])
def test_tripcolor(): x = np.asarray([0, 0.5, 1, 0, 0.5, 1, 0, 0.5, 1, 0.75]) y = np.asarray([0, 0, 0, 0.5, 0.5, 0.5, 1, 1, 1, 0.75]) triangles = np.asarray([ [0, 1, 3], [1, 4, 3], [1, 2, 4], [2, 5, 4], [3, 4, 6], [4, 7, 6], [4, 5, 9], [7, 4, 9], [8, 7, 9], [5, 8, 9]]) # Triangulation with same number of points and triangles. triang = mtri.Triangulation(x, y, triangles) Cpoints = x + 0.5*y xmid = x[triang.triangles].mean(axis=1) ymid = y[triang.triangles].mean(axis=1) Cfaces = 0.5*xmid + ymid plt.subplot(121) plt.tripcolor(triang, Cpoints, edgecolors='k') plt.title('point colors') plt.subplot(122) plt.tripcolor(triang, facecolors=Cfaces, edgecolors='k') plt.title('facecolors')
def mplot_function(f, vmin, vmax, logscale): mesh = f.function_space().mesh() if (mesh.geometry().dim() != 2): raise AttributeError('Mesh must be 2D') # DG0 cellwise function if f.vector().size() == mesh.num_cells(): C = f.vector().array() if logscale: return plt.tripcolor(mesh2triang(mesh), C, vmin=vmin, vmax=vmax, norm=cls.LogNorm() ) else: return plt.tripcolor(mesh2triang(mesh), C, vmin=vmin, vmax=vmax) # Scalar function, interpolated to vertices elif f.value_rank() == 0: C = f.compute_vertex_values(mesh) if logscale: return plt.tripcolor(mesh2triang(mesh), C, vmin=vmin, vmax=vmax, norm=cls.LogNorm() ) else: return plt.tripcolor(mesh2triang(mesh), C, shading='gouraud', vmin=vmin, vmax=vmax) # Vector function, interpolated to vertices elif f.value_rank() == 1: w0 = f.compute_vertex_values(mesh) if (len(w0) != 2*mesh.num_vertices()): raise AttributeError('Vector field must be 2D') X = mesh.coordinates()[:, 0] Y = mesh.coordinates()[:, 1] U = w0[:mesh.num_vertices()] V = w0[mesh.num_vertices():] C = np.sqrt(U*U+V*V) return plt.quiver(X,Y,U,V, C, units='x', headaxislength=7, headwidth=7, headlength=7, scale=4, pivot='middle')
def draw(self, x = (), y=()): #px,py = self.points.to(self.env_model.ROW_COL) plt.tripcolor(self.x, self.y, self.mesh.faces, facecolors=self.zfaces, edgecolors='k') if len(x) != 0: plt.plot(x, y) plt.axis('equal') plt.show()
def field(domain, z, title, clim = None, path=None, save=True, show = False, ics=1, ext='.png', cmap=plt.cm.jet, fmt=None): """ Given a domain, plot the nodal value z :param domain: :class:`~polyadcirc.run_framework.domain` :param z: :class:`numpy.ndarray` :param string title: plot title :param clim: :class:`numpy.clim` :type path: string or None :param path: directory to store plots :type save: bool :param save: flag for whether or not to save plots :type show: bool :param show: flag for whether or not to show plots :param int ics: polar coordinate option (1 = cart coords, 2 = polar coords) :param string ext: file extension :param callable fmt: formatter for color bar, takes ``(x, pos)`` returns ``string`` """ if path is None: path = os.getcwd() plt.figure() plt.tripcolor(domain.triangulation, z, shading='gouraud', cmap=cmap) plt.gca().set_aspect('equal') plt.autoscale(tight=True) if clim: plt.clim(clim[0], clim[1]) add_2d_axes_labels(ics=ics) colorbar(fmt=fmt) #plt.title(title) save_show(os.path.join(path, 'figs', title), save, show, ext)
def showSolution(self,dim=2): from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm, pyplot x,y,tri,solution,grad = [],[],[],[],[] for n in self.node: x.append(n.x) y.append(n.y) solution.append(n.value) for e in self.element: tri.append([n.id for n in e.node]) grad.append(e.grad()) if dim==2: pyplot.figure(figsize=(17,6)) pyplot.subplot(1,2,1) pyplot.title("Solution") pyplot.tripcolor(x, y, tri, solution, cmap=cm.jet, edgecolors='black') pyplot.colorbar() pyplot.subplot(1,2,2) pyplot.title("Gradient") pyplot.tripcolor(x, y, tri, grad, cmap=cm.jet, edgecolors='black') pyplot.colorbar() elif dim==3: fig = pyplot.figure() ax = fig.gca(projection='3d') ax.plot_trisurf(x, y, tri, z, cmap=cm.jet, linewidth=0.2) pyplot.show()
def quick_plot(bmi, name, **kwds): gid = bmi.var_grid(name) gtype = bmi.grid_type(gid) grid = bmi.grid[gid] x, y = grid.node_x.values, grid.node_y.values z = bmi.get_value(name) x_label = "{name} ({units})".format( name=grid.node_x.standard_name, units=grid.node_x.units ) y_label = "{name} ({units})".format( name=grid.node_y.standard_name, units=grid.node_y.units ) if gtype in ("unstructured_triangular",): tris = bmi.grid_face_node_connectivity(gid).reshape((-1, 3)) plt.tripcolor(x, y, tris, z, **kwds) elif gtype in ("uniform_rectilinear", "structured_quad"): shape = bmi.grid_shape(gid) spacing = bmi.grid_spacing(gid) origin = bmi.grid_origin(gid) x = np.arange(shape[-1]) * spacing[-1] + origin[-1] y = np.arange(shape[-2]) * spacing[-2] + origin[-2] plt.pcolormesh(x, y, z.reshape(shape), **kwds) else: raise ValueError("no plotter for {gtype}".format(gtype=gtype)) plt.axis("tight") plt.gca().set_aspect("equal") plt.xlabel(x_label) plt.ylabel(y_label) cbar = plt.colorbar() cbar.ax.set_ylabel("{name} ({units})".format(name=name, units=bmi.var_units(name)))
def el_plot(data, Map=False, show=True): """ Plot the elevation for the region from the last time series :Parameters: **data** -- the standard python data dictionary **Map** -- {True, False} (optional): Optional argument. If True, the elevation will be plotted on a map. """ trigrid = data['trigrid'] plt.gca().set_aspect('equal') plt.tripcolor(trigrid, data['zeta'][-1,:]) plt.colorbar() plt.title("Elevation") if Map: #we set the corners of where the map should show up llcrnrlon, urcrnrlon = plt.xlim() llcrnrlat, urcrnrlat = plt.ylim() #we construct the map. Note that resolution serves to increase #or decrease the detail in the coastline. Currently set to #'i' for 'intermediate' m = Basemap(llcrnrlon, llcrnrlat, urcrnrlon, urcrnrlat, \ resolution='i', suppress_ticks=False) #set color for continents. Default is grey. m.fillcontinents(color='ForestGreen') m.drawmapboundary() m.drawcoastlines() if show: plt.show()
def field(domain, z, title, clim = None, path=None, save=True, show = False, ics=1, ext='.png', cmap=plt.cm.jet): """ Given a domain, plot the nodal value z :param domain: :class:`~polyadcirc.run_framework.domain` :param z: :class:`np.array` :param string title: plot title :param clim: :class:`np.clim` :type path: string or None :param path: directory to store plots :type save: boolean :param save: flag for whether or not to save plots :type show: boolean :param show: flag for whether or not to show plots :param int ics: polar coordinate option (1 = cart coords, 2 = polar coords) :param string ext: file extension """ if path == None: path = os.getcwd() plt.figure() plt.tripcolor(domain.triangulation, z, shading='gouraud', cmap=cmap) plt.gca().set_aspect('equal') plt.autoscale(tight=True) if clim: plt.clim(clim[0], clim[1]) add_2d_axes_labels(ics) colorbar() #plt.title(title) save_show(path+'/figs/'+title, save, show, ext)
def triangle_vert_plot(filename, args): dset = gusto_dataset.GustoDataset(filename) x = dset.get_vert_variable('x1') z = dset.get_vert_variable('x3') f = dset.get_vert_variable(args.data) plt.tripcolor(x, z, f) plt.axis('equal')
def triangle_variable_plot(filename, args): dset = gusto_dataset.GustoDataset(filename) x = dset.get_cell_variable('x1') z = dset.get_cell_variable('x3') f = dset.get_cell_variable('dg') plt.tripcolor(x, z, f) plt.axis('equal') plt.colorbar()
def plot_latlon_tri(lon=None, lat=None, data=None, title='Title', vmin_in=CBAR_MINT, vmax_in=CBAR_MAXT): triang = tri.Triangulation(lon, lat) fig, ax = plt.subplots() plt.gca().set_aspect('equal') plt.tripcolor(triang, data, cmap=cm.jet, vmin=vmin_in, vmax=vmax_in) label_plot(fig, ax, title) return fig
def plot_faces(nodes,faces,fn,cmap=None): fn = np.ma.array(fn,mask=~np.isfinite(fn)) assert(fn.size == faces.shape[0]) if cmap is None: cmap = plt.get_cmap('jet') cmap.set_bad('w',1.) plt.gca() plt.tripcolor(nodes[:,0],nodes[:,1],faces,facecolors=fn, edgecolor='k',cmap=cmap) plt.colorbar()
def postprocessor(nodes, val): x = nodes[:, 0] y = nodes[:, 1] fig = plt.figure() plt.gca().set_aspect('equal') plt.tripcolor(x,y,elements,facecolors=val,edgecolors='k') plt.colorbar() plt.title("Poisson's equation") plt.xlabel('x') plt.ylabel('y') #plt.savefig("FEM.png") plt.show()
def highlightTriangle(index): #give this function the index of element and it will highlight clickedTriangleX = [x[elements[index][0]],x[elements[index][1]],x[elements[index][2]]] clickedTriangleY = [y[elements[index][0]],y[elements[index][1]],y[elements[index][2]]] plt.tripcolor(clickedTriangleX,clickedTriangleY,[0,1,2],cmap=plt.cm.Accent) a = elements[index] x1 = x[a[0]] x2 = x[a[1]] x3 = x[a[2]] y1 = y[a[0]] y2 = y[a[1]] y3 = y[a[2]] centroid = tuple(((x1+x2+x3)/3,(y1+y2+y3)/3)) if centroid not in visible: visible[centroid] = plt.text(centroid[0], centroid[1], '.' + str(index))
def onclick(event): #print('button=%d, x=%d, y=%d, xdata=%f, ydata=%f'%(event.button, event.x, event.y, event.xdata, event.ydata)) #print(event.button, event.x, event.y, event.xdata, event.ydata) if event.xdata < maxX and event.xdata > minX and event.ydata < maxY and event.ydata > minY: if event.key in ['alt+q','q'] or event.key in ['alt+w','w']: # TODO: put clicked triangles into an array # after a certain number of clicks, we want to remake the plot, to prevent recursion depth error if event.xdata < maxX or event.xdata > minX or event.ydata < maxY or event.ydata > minY: jump = index = len(orderedCentroids) // 2 # Complexity of log(n) - ordered binary search to get to the nearest X while True: jump = jump //2 if jump < 1 or event.xdata == orderedCentroids[index][0]: break index += jump * (int(event.xdata > orderedCentroids[index][0]) - int(event.xdata < orderedCentroids[index][0])) # Bounce outward checking if point is inside triangle who's centroid is centroid of list (to skip Y checking) jump = 1 while True: if inTriangle(event.xdata,event.ydata,allTriangles[orderedCentroids[index]]): break index += jump * (1-2*(jump % 2 == 0)) jump += 1 # Find which 3 points make up the triangle clickedTriangle = allTriangles[orderedCentroids[index]] clickedTriangleX = [clickedTriangle[0][0],clickedTriangle[1][0],clickedTriangle[2][0]] clickedTriangleY = [clickedTriangle[0][1],clickedTriangle[1][1],clickedTriangle[2][1]] if event.key in ['alt+q','q']: if orderedCentroids[index] not in visible: plt.tripcolor(clickedTriangleX,clickedTriangleY,[0,1,2],cmap=plt.cm.Accent) visible[orderedCentroids[index]] = plt.text(orderedCentroids[index][0], orderedCentroids[index][1], '.' + str(clickedTriangle[3])) elif event.key in ['alt+w','w']: if orderedCentroids[index] in visible: plt.tripcolor(clickedTriangleX,clickedTriangleY,[0,1,2],cmap=plt.cm.Greys) visible[orderedCentroids[index]].remove() del visible[orderedCentroids[index]] elif event.key in ['alt+e','e']: typedInput = input('Enter triangle index to highlight: ') try: typedInput = int(typedInput) highlightTriangle(typedInput) except: print('Invalid Input') plt.draw()
def plot_f_m3d_hdf5_2D(filename,time_id,data_id,plane_id): import matplotlib.pyplot as plt import matplotlib.tri as triangle from matplotlib.pyplot import figure, axes, plot, xlabel, ylabel, title, \ grid, savefig, show (timeframe,nnode_1_plane,R,Z,trianlist,data_name,data_2D)=readhdf5_f_time_data(filename,time_id,data_id,plane_id) #plt.gca().set_aspect('equal') tri=triangle.Triangulation(R,Z) fig = figure(figsize=(6,8)) plt.tripcolor(tri,data_2D) plt.xlabel('R') plt.ylabel('Z'); title_str=format('%s, t=%f'%(data_name,timeframe)) plt.title(title_str) plt.colorbar() plt.show()
def plot(self, savename, astr='.*_fcomp(.*)_focean(.*)_CPL', xlabel='fcomp', ylabel='focean'): """ astr is used to build indices from files""" matcher = re.compile(astr) matches = [(matcher.findall(af)[0][0], matcher.findall(af)[0][1], val) for af, val in zip(self.files, self.vals) if matcher.findall(af) != []] points = np.squeeze(np.asarray(matches, dtype='f8')) plt.figure() tri = Triangulation(points[:,0], points[:,1]) plt.tripcolor(tri, points[:,2], cmap='viridis') plt.colorbar() plt.xlabel(xlabel) plt.ylabel(ylabel) plt.title(self.units) plt.savefig(savename + '.png') return #}}}
def X_plot_sph(particles, time= 0.0|units.day): pyplot.rcParams.update({'font.size': 30}) figure = pyplot.figure(figsize=(12, 12)) #f, ax = pyplot.subplots(1,2, sharex=True, sharey=True) x = particles.x.value_in(units.RSun) y = particles.y.value_in(units.RSun) z = particles.rho.value_in(units.g/units.cm**3) cax = pyplot.tripcolor(x,y,z) max_dens = z.max() min_dens = z.min() mid_dens = 0.5*(max_dens+min_dens) # cbar = pyplot.colorbar() print "dens=", min_dens, mid_dens, max_dens # cbar = figure.colorbar(cax, ticks=[min_dens, mid_dens, max_dens], orientation='vertical', fraction=0.045) # cbar.ax.set_yticklabels(['Low', ' ', 'High']) # cbar.set_label('mid-plane density', rotation=270) pyplot.xlim(0, 10) pyplot.ylim(0, 10) pyplot.xlabel("x [R$_\odot$]") pyplot.ylabel("y [R$_\odot$]") t = int(time.value_in(units.s)) filename = "supernova_sph_T"+str(t)+".png" pyplot.savefig(filename) pyplot.show()
def plot_fill(value_array,title,sym=0): x = nodearray[:,0] y = nodearray[:,1] triangles = np.array(elements) if sym: x = np.append(x,-x) y = np.append(y,y) triangles = np.vstack((triangles, triangles+np.amax(triangles)+1)) value_array = np.append(value_array,value_array) plt.figure() plt.title(title) plt.axes().set_aspect('equal') plt.tripcolor(x,y,triangles,value_array, edgecolors='k',cmap=plt.get_cmap('jet')) plt.colorbar()
def plotmesh(Mesh, color): V = Mesh['V'] E = Mesh['E'] BE = Mesh['BE'] F = np.zeros((np.size(E)/3, 1)) F = F[:,0] F[:] = 1 plt.tripcolor(V[:,0], V[:,1], triangles=E, facecolors=F, edgecolors=color, cmap=plt.cm.gray, vmin=0, vmax=1, alpha=1, linewidth=0.5) for i in range(len(BE)): x = [V[BE[i,0],0], V[BE[i,1],0]] y = [V[BE[i,0],1], V[BE[i,1],1]] plt.plot(x, y, '-', linewidth=2.5, color=color) plt.axis('equal') plt.axis([-100, 100,-100, 100])
def plot_mizes(nodes, elements, mizes, saveimage=False): x = nodes[:, 0] y = nodes[:, 1] plt.figure() plt.gca().set_aspect('equal') plt.tripcolor(x, y, elements, facecolors=mizes, edgecolors='k') plt.colorbar() plt.title("von-Mizes stress") plt.xlabel('x') plt.ylabel('y') plt.axis('tight') if saveimage == True: plt.savefig("mizes.png") plt.show()
def Plot3DFile(fname, CMAP='gist_rainbow', x=1, y=2, z=3): Inarray=np.loadtxt(fname); X=Inarray[:,x-1]; Y=Inarray[:,y-1]; Z=Inarray[:,z-1]; ax=plt.subplot() p=plt.tripcolor(X, Y, Z, cmap=CMAP) plt.colorbar(p, ax=ax) return
def station_locations(domain, path=None, bathy = False, save=True, show=False, ics=1, ext='.png', station_markers=None): """ Given a domain, plot the observation stations :param domain: :class:`~polyadcirc.run_framework.domain` :type path: string or None :param path: directory to store plots :type bathy: bool :param bathy: flat for whether or not to show bathymetry :type save: bool :param save: flag for whether or not to save plots :type show: bool :param show: flag for whether or not to show plots :param int ics: coordinate system (1 cartisian, 2 polar) :param string ext: file extesion """ plt.figure() if path is None: path = os.getcwd() if bathy: z = np.array([n.bathymetry for n in domain.node.itervalues()]) plt.tripcolor(domain.triangulation, z, shading='gouraud', cmap=plt.cm.ocean) plt.gca().set_aspect('equal') else: plt.triplot(domain.triangulation, 'k-') plt.gca().set_aspect('equal') if station_markers is None: station_markers = _stationmarkers for k, v in domain.stations.iteritems(): x = np.array([e.x for e in v]) y = np.array([e.y for e in v]) plt.plot(x, y, station_markers[k], label = k) #plt.title('station locations') add_2d_axes_labels(ics=ics) #plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, # ncol=2, mode="expand", borderaxespad=0.) save_show(os.path.join(path, 'figs', 'station_locations'), save, show, ext)
def bathymetry(domain, path=None, save=True, show=False, mesh = False, contour = False, ics=1, ext='.png', title=False): """ Given a domain, plot the bathymetry :param domain: :class:`~polyadcirc.run_framework.domain` :type path: string or None :param path: directory to store plots :type save: bool :param save: flag for whether or not to save plots :type show: bool :param show: flag for whether or not to show plots :type mesh: bool :param mesh: flag for whether or not to show mesh :param bool contour: use :meth:`~np.pyplot.tripcolor` or :meth:`~np.pyplot.tricontour` :param int ics: coordinate system (1 cartisian, 2 polar) :param string ext: file extesion """ z = domain.array_bathymetry() vmax = np.max(z) vmin = np.min(z) clim = (vmin, vmax) if path is None: path = os.getcwd() plt.figure() if mesh: plt.triplot(domain.triangulation, 'k-') if not contour: plt.tripcolor(domain.triangulation, z, shading='gouraud', cmap=plt.cm.ocean) else: plt.tricontourf(domain.triangulation, z, cmap=plt.cm.ocean) plt.gca().set_aspect('equal') add_2d_axes_labels(ics=ics) if clim: plt.clim(clim[0], clim[1]) if title: plt.title('bathymetry') colorbar() save_show(os.path.join(path, 'figs', 'bathymetry'), save, show, ext)
def computeScatteringMatrix(self,Mmax): # -- Prepare scattering matrix. scatMat = np.zeros((2*Mmax+1,2*Mmax+1), dtype=np.complex) for n in range(2*Mmax+1): m = n-Mmax # -- Prepare the vector and matrix b = np.zeros((self.nTriangles), dtype=np.complex) M = np.zeros((self.nTriangles,self.nTriangles), dtype=np.complex) for i in range(self.nTriangles): b[i] = jn(m, self.k*np.linalg.norm(self.centerPoints[i]))*np.exp(1j*m*user_mod(np.arctan2(self.centerPoints[i,1],self.centerPoints[i,0]),2*np.pi)) for j in range(self.nTriangles): if (i!=j): d = self.k*np.linalg.norm(self.centerPoints[i]-self.centerPoints[j]) phi1 = user_mod(np.arctan2(self.centerPoints[i,1],self.centerPoints[i,0]),2*np.pi) phi2 = user_mod(np.arctan2(self.centerPoints[j,1],self.centerPoints[j,0]),2*np.pi) M[i,j] = self.potential*self.k*self.k*1j*hankel1(0, d)*self.areas[j]/4.0 x = np.linalg.solve(np.eye(self.nTriangles,self.nTriangles, dtype=np.complex)-M,b) fig2 = plt.figure(figsize=(3,3)) ax2 = fig2.add_subplot(111) ax2.axis('off') plt.tripcolor(self.points[:,0], self.points[:,1],self.triangulation.simplices, np.abs(x)) plt.savefig("intensityTest-%s.pdf" %(self.N)) # -- We compute the corresponding line of the scattering matrix. for k in range(2*Mmax+1): mp = k-Mmax Smm = 0.0 for h in range(self.nTriangles): d = self.k*np.linalg.norm(self.centerPoints[h]) phi = user_mod(np.arctan2(self.centerPoints[h,1],self.centerPoints[h,0]),2*np.pi) Smm += self.potential*jn(mp,d)*np.exp(-1j*mp*phi)*x[h]*self.areas[h] Smm = self.k*self.k*1j*Smm/2.0 Smm += (1.0 if mp==m else 0.0) scatMat[k,n] = Smm return scatMat
def plotwinkeltriple(d,v, vmin=None, vmax=None): """ Plots a winkel projection of a function on a sphere evaluated at directions d v - values """ # phi = n.arctan2(d[:,2],n.linalg.norm(d[:,0:2],axis=1)).reshape((-1,)) phi = n.arctan2(d[:,2],n.linalg.norm(d[:,0:2],axis=1)).reshape((-1,)) theta = n.arctan2(d[:,1],d[:,0]).reshape((-1,)) x,y = winkeltriple(theta,phi) t_border = n.concatenate( [ n.linspace(n.pi,-n.pi,50), n.ones(50)*-n.pi, n.linspace(-n.pi,n.pi,50), n.ones(50)*n.pi ] ) ph_border = n.concatenate( [ n.ones(50)*-n.pi/2.0, n.linspace(-n.pi/2,n.pi/2.0,50), n.ones(50)*n.pi/2.0, n.linspace(n.pi/2.0,-n.pi/2.0,50) ] ) x_border,y_border = winkeltriple(t_border,ph_border) plt.hold(True) plt.tripcolor(x,y,1e-10 + v,shading='gourad',vmin=vmin+1e-10,vmax=vmax+1e-10,norm=colors.LogNorm()) plt.plot(x_border,y_border,'-k') plt.colorbar() plt.show()
def Compare3DFiles(fname1, fname2, CMAP='gist_rainbow', x=1, y=2, z1=3, z2=3): Inarray=np.loadtxt(fname1); X=Inarray[:,x-1]; Y=Inarray[:,y-1]; Z1=Inarray[:,z1-1]; Inarray2=np.loadtxt(fname2); Z2=Inarray2[:,z2-1]; difZ=Z1-Z2 ax=plt.subplot() p=plt.tripcolor(X, Y, difZ, cmap=CMAP) plt.colorbar(p, ax=ax) return
def plotq2_unst(outputdir, n1, m, meqn, NumPhysElems, NumPhysNodes, xlow, xhigh, ylow, yhigh, time, x, y, tnode, qsoln, xmid, ymid, qsoln_elem): import numpy as np import matplotlib.pyplot as plt from math import sqrt from math import pow from math import cos from math import sin from math import pi plt.figure(1) plt.clf() plt.gca().set_aspect('equal') plt.gca().set_xlim([xlow,xhigh]) #plt.gca().set_ylim([ylow,yhigh]) p1=plt.tripcolor(x, y, tnode, qsoln[:,m], shading='faceted', vmin=0.0, vmax=1.0) tmp1 = "".join(("q(",str(m+1),") at t = ")) tmp2 = "".join((tmp1,str(time))) title = "".join((tmp2," [DoGPack]")) plt.title(title) plt.colorbar() plt.draw() x0 = -0.25*cos(2.0*pi*time) + 0.50 y0 = 0.25*sin(2.0*pi*time) + 0.50 r = np.zeros(NumPhysElems,float) for i in range(0,NumPhysElems): r[i] = sqrt(pow(xmid[i]-x0,2)+pow(ymid[i]-y0,2)) ind = r.argsort() qscat_ex = np.zeros((NumPhysElems,meqn),float) qex(NumPhysElems,meqn,r,qscat_ex) err = np.linalg.norm(qscat_ex[:,m]-qsoln_elem[:,m])/np.linalg.norm(qscat_ex[:,m]) print "" print " Error = ",'{:e}'.format(err) print "" plt.figure(2) plt.clf() plt.gca().set_aspect('auto') plt.gca().set_xlim([0.0,0.5]) #plt.gca().set_ylim([0.0,1.0]) plt.plot(r[ind],qscat_ex[ind,m],'k-') plt.plot(r[ind],qsoln_elem[ind,m],'bo') tmp1 = "".join(("Scattor plot of q(",str(m+1),") at t = ")) tmp2 = "".join((tmp1,str(time))) title = "".join((tmp2," [DoGPack]")) plt.title(title) plt.draw()
def viz_sol(uh, nodes, triangles): """ Visualize the NIROM and HFM solutions over the physical domain """ boundaries = np.linspace(np.amin(uh), np.amax(uh), 11) cf = plt.tripcolor(nodes[:, 0], nodes[:, 1], triangles, uh, shading='gouraud') plt.axis('equal') return cf, boundaries
def plot(obj, title): plt.gca().set_aspect('equal') if isinstance(obj, df.Function): mesh = obj.function_space().mesh() if (mesh.geometry().dim() != 2): raise (AttributeError) if obj.vector().size() == mesh.num_cells(): C = obj.vector().get_local() plt.tripcolor(mesh2triang(mesh), C, cmap='viridis') plt.colorbar() plt.title(title) else: C = obj.compute_vertex_values(mesh) plt.tripcolor(mesh2triang(mesh), C, shading='gouraud', cmap='viridis') plt.colorbar() plt.title(title) elif isinstance(obj, df.Mesh): if (obj.geometry().dim() != 2): raise (AttributeError) plt.triplot(mesh2triang(obj), color='k')
def test_tripcolor(): x = np.asarray([0, 0.5, 1, 0, 0.5, 1, 0, 0.5, 1, 0.75]) y = np.asarray([0, 0, 0, 0.5, 0.5, 0.5, 1, 1, 1, 0.75]) triangles = np.asarray([[0, 1, 3], [1, 4, 3], [1, 2, 4], [2, 5, 4], [3, 4, 6], [4, 7, 6], [4, 5, 9], [7, 4, 9], [8, 7, 9], [5, 8, 9]]) # Triangulation with same number of points and triangles. triang = mtri.Triangulation(x, y, triangles) Cpoints = x + 0.5 * y xmid = x[triang.triangles].mean(axis=1) ymid = y[triang.triangles].mean(axis=1) Cfaces = 0.5 * xmid + ymid plt.subplot(121) plt.tripcolor(triang, Cpoints, edgecolors='k') plt.title('point colors') plt.subplot(122) plt.tripcolor(triang, facecolors=Cfaces, edgecolors='k') plt.title('facecolors')
def plot_SubTh2simp2D(q, me, u, **kwargs): plane = kwargs.pop('plane', True) shading = kwargs.pop('shading', 'gouraud') kwargs['vmin'] = kwargs.get('vmin', np.min(u)) kwargs['vmax'] = kwargs.get('vmax', np.max(u)) fig = plt.gcf() if plane: return plt.tripcolor( q[:, 0], q[:, 1], me, u, shading=shading, **kwargs) #vmin=vmin,vmax=vmax, shading=shading,**kwargs) nq = q.shape[0] assert isinstance(u, np.ndarray) and u.shape[0] == nq Q = np.concatenate((q, u.reshape((nq, 1))), axis=1) return plot_SubTh2simp3D(Q, me, u, **kwargs)
def viz_err(uh, snap, nodes, triangles): """ Visualize the NIROM solution relative error over the domain """ cf3 = plt.tripcolor(nodes[:, 0], nodes[:, 1], triangles, uh - snap, shading='flat') plt.axis('equal') cb = plt.colorbar(cf3) return cf3
def plotCSpaceDelaunayGrey(fname1,fname2,P1,P2,maximumEdgeLength=0.2, shade=0.8): points2D=np.vstack([P1,P2]).T print(points2D) tri = Delaunay(points2D) # print tri.simplices.shape, '\n', tri.simplices[0] triangles = np.empty((0,3),dtype=int) for i in range(0, tri.simplices.shape[0]): simplex = tri.simplices[i] x = tri.points[simplex[0]] y = tri.points[simplex[1]] z = tri.points[simplex[2]] d0 = np.sqrt(np.dot(x-y,x-y)) d1 = np.sqrt(np.dot(x-z,x-z)) d2 = np.sqrt(np.dot(z-y,z-y)) max_edge = max([d0, d1, d2]) if max_edge <= maximumEdgeLength: triangles = np.vstack((triangles, simplex)) zFaces = np.ones(triangles.shape[0]) cmap = colors.LinearSegmentedColormap.from_list("", [(shade,shade,shade),"grey","grey"]) plt.tripcolor(P1, P2, triangles, cmap=cmap, facecolors=zFaces,edgecolors='none')
def postprocessor(nodes, slv): x = nodes[:, 0] y = nodes[:, 1] # Color value val = [] for element in elements: p0 = slv[element[0]] p1 = slv[element[1]] p2 = slv[element[2]] val.append((p0 + p1 + p2) / 3.) val = array(val) plt.figure() plt.gca().set_aspect('equal') plt.tripcolor(x, y, elements, facecolors=val, edgecolors='k') plt.colorbar() plt.title("Poisson's equation") plt.xlabel('x') plt.ylabel('y') #plt.savefig("FEM.png") plt.show() print "val\n", val
def plot_shortest_path(self, start, end, subdivisions=1): graph = self._create_graph(self.triangulation, subdivisions=subdivisions) cost, path = self.shortest_path(start, end, subdivisions) plt.figure() plt.gca().set_aspect('equal') for edge in graph: p1 = edge[0] p2 = edge[1] plt.plot([p1[0], p2[0]], [p1[1], p2[1]], 'g:', alpha=0.5) tri_plot = plt.tripcolor(self.triangulation, self.triangle_weights, cmap=plt.cm.RdYlGn_r) plt.plot([p[0] for p in path], [p[1] for p in path], 'k', lw=3) plt.colorbar(tri_plot) plt.show()
def isomap_patch(mesh, mask, show=False): """return low-dimensional coordinates for the the patch Parameters ========== mesh: string or nibabel mesh, the input mesh to be cherted mask: string or array of shape (n_vertices) a mask for the region of interest on the mesh show: boolean, optional, if yes, make an image of the coordinates """ from sklearn.manifold.isomap import Isomap # Read the data coord, tri = mesh_arrays(mesh) if isinstance(mask, basestring): mask = gifti.read(mask).darrays[0].data > 0 else: mask = mask.astype(np.bool) coord, tri = coord[mask], tri[mask[tri].all(1)] tri = np.hstack((0, np.cumsum(mask)[:-1]))[tri] # perform the dimension reduction xy = Isomap().fit_transform(coord) # try to make the sign invariant and repect the orientations xy *= np.sign((xy**3).sum(0)) a, b, c = tri[0] xy[:, 1] *= np.sign(np.linalg.det(np.vstack((xy[b] - xy[a], xy[c] - xy[a])))) if show: import matplotlib.pyplot as plt plt.figure() plt.tripcolor(xy.T[0], xy.T[1], tri, (xy**2).sum(1), shading='faceted') plt.show() return xy
def plotwinkeltriple(d, v, vmin=None, vmax=None): """ Plots a winkel projection of a function on a sphere evaluated at directions d v - values """ # phi = np.arctan2(d[:,2],np.linalg.norm(d[:,0:2],axis=1)).reshape((-1,)) phi = np.arctan2(d[:, 2], np.linalg.norm(d[:, 0:2], axis=1)).reshape( (-1, )) theta = np.arctan2(d[:, 1], d[:, 0]).reshape((-1, )) x, y = winkeltriple(theta, phi) t_border = np.concatenate([ np.linspace(np.pi, -np.pi, 50), np.ones(50) * -np.pi, np.linspace(-np.pi, np.pi, 50), np.ones(50) * np.pi ]) ph_border = np.concatenate([ np.ones(50) * -np.pi / 2.0, np.linspace(-np.pi / 2, np.pi / 2.0, 50), np.ones(50) * np.pi / 2.0, np.linspace(np.pi / 2.0, -np.pi / 2.0, 50) ]) x_border, y_border = winkeltriple(t_border, ph_border) plt.hold(True) plt.tripcolor(x, y, 1e-10 + v, shading='gouraud', vmin=vmin + 1e-10, vmax=vmax + 1e-10, norm=colors.LogNorm()) plt.plot(x_border, y_border, '-k') plt.colorbar() plt.show()
def plt_im_tri(self, depth, fig_name, show_file=True, vmin_=21.0, vmax_=29.0): mesh = loadmat("mesh.mat") triangles = mesh['triangles'] meshnode = mesh['meshnode'] # velocity_obs_loc = np.loadtxt("observation_loc_drogue12345_50ft.dat") # bathy = loadmat('true.mat') # z_in = np.squeeze(bathy['s_true']) # true in meter matplotlib.rcParams.update({'font.size': 16}) offsetx = 220793. offsety = 364110. fig_index = 1 plt.figure(fig_index, figsize=(10., 10.), dpi=100) fig_index += 1 ax = plt.gca() im = plt.tripcolor(meshnode[:, 0] * 0.3010 - offsetx, meshnode[:, 1] * 0.3010 - offsety, triangles, depth * 0.301, cmap=plt.get_cmap('jet'), vmin=vmin_, vmax=vmax_, label='_nolegend_') ax.set_xlabel("Easting [m]") ax.set_ylabel("Northing [m]") plt.gca().set_aspect('equal', adjustable='box') plt.axis([0., 1000., 0., 530.]) plt.xticks(np.arange(0., 1000. + 10., 200.0)) plt.yticks(np.arange(0., 530. + 10., 200.0)) cbar = plt.colorbar(im, fraction=0.025, pad=0.05) # cbar = plt.colorbar(im, pad=0.05 ) cbar.set_label('Elevation [m]') plt.rcParams['axes.axisbelow'] = True plt.rc('axes', axisbelow=True) plt.grid() ax.set_axisbelow(True) plt.tight_layout() plt.savefig(fig_name) if show_file: plt.show()
def plotq2np_unst(m,meqn,NumPhysElems,NumPhysNodes,xlow,xhigh,ylow,yhigh,time,x,y,tnode,qsoln,xmid,ymid,qsoln_elem,FRAME): import matplotlib.pyplot as plt plt.figure(FRAME) plt.clf() plt.gca().set_aspect('equal') plt.gca().set_xlim([xlow,xhigh]) plt.gca().set_ylim([ylow,yhigh]) p1=plt.tripcolor(x, y, tnode, qsoln[:,m], shading='flat') tmp1 = "".join(("q(",str(m+1),") at t = ")) tmp2 = "".join((tmp1,str(time))) title = "".join((tmp2," [DoGPack]")) plt.title(title) plt.draw()
def plot_tree(n, res=100, scaling="normal", colorbar=False, cmap="RdBu_r", clim=None): import dufte import meshzoo from matplotlib import pyplot as plt plt.style.use(dufte.style) bary, cells = meshzoo.triangle(res) evaluator = Eval(bary, scaling) plt.set_cmap(cmap) plt.gca().set_aspect("equal") plt.axis("off") for k, level in enumerate(itertools.islice(evaluator, n + 1)): for r, z in enumerate(level): alpha = numpy.pi * numpy.array([7.0 / 6.0, 11.0 / 6.0, 3.0 / 6.0]) corners = numpy.array([numpy.cos(alpha), numpy.sin(alpha)]) corners[0] += 2.1 * (r - k / 2) corners[1] -= 1.9 * k x, y = numpy.dot(corners, bary) plt.tripcolor(x, y, cells, z, shading="flat") plt.clim(clim) # triangle outlines X = numpy.column_stack([corners, corners[:, 0]]) plt.plot(X[0], X[1], "-k") if colorbar: plt.colorbar()
def plot_carpet_2d(mesh, f, result_path): num_cells = mesh.num_cells() num_verts = mesh.num_vertices() d = mesh.geometry().dim() # Create the triangulation mesh_coordinates = mesh.coordinates().reshape((num_verts, d)) triangles = numpy.asarray([cell.entities(0) for cell in cells(mesh)]) triangulation = tri.Triangulation(mesh_coordinates[:, 0], mesh_coordinates[:, 1], triangles) # Get the z values as face colors for each triangle(midpoint) fig = plt.figure() # Get the z values for each vertex plt.figure() plt.xlabel('x') plt.ylabel('y') z = numpy.asarray([f(point) for point in mesh_coordinates]) plt.tripcolor(triangulation, z, cmap=cm.coolwarm, edgecolors='k') fig = plt.gcf() fig.savefig(result_path + "-cells-%d-vertices-%d.eps" % (num_cells, num_verts))
def plot_faces(coords, faces, face_values=None, title=None, clabel=None, colorbar=True, save=None, show=True, latex=False): """ Plot a mesh with values given at faces. """ if face_values is None: colors = np.arange(len(faces)) clabel = "Face number" else: colors = face_values fig = Figure(title=title, clabel=clabel, colorbar=colorbar, save=save, show=show, latex=latex) fig.colorbar_ax = plt.tripcolor(coords[:, 0], coords[:, 1], faces, facecolors=colors, edgecolors='k') ax = plt.gca() ax.set_xlim([coords[:, 0].min(), coords[:, 0].max()]) ax.set_ylim([coords[:, 1].min(), coords[:, 1].max()]) return fig
def plot_sphere_a(self, sph): self.fig = plt.figure() #self.ax = self.fig.add_subplot(111, projection='3d')#.gca(projection='3d')projection = 'mollweide' #self.ax = self.fig.add_subplot(111)#, projection = '3d') #'mollweide')#.gca(projection='3d')projection = 'mollweide' #self.ax.view_init(elev=90., azim=0) #self.ax.axis([-1,1,-1,1, -1, 1]) """ self.ax.set_xlim(-0.55, 0.55) self.ax.set_ylim(-0.55, 0.55) self.ax.set_zlim(-0.55, 0.55) """ #plt.gca().set_aspect('equal') #axes = plt.gca() #axes.set_xlim([-4,4]) #axes.set_ylim([-5,35]) self.x, self.y, self.z = sph.ch.points[ sph.ch.vertices][:, 0], sph.ch.points[ sph.ch.vertices][:, 1], sph.ch.points[sph.ch.vertices][:, 2] #print("self.x", self.x) #self.avg = (self.xc+ self.yc+ self.zc)/3 #self.x, self.y = sph.Mercator_Projection(-2.3*np.pi/8.)#sph.Mercator_Projection()#s#Mollewide self.z = np.zeros(self.x.shape) self.triangles = sph.ch.simplices #self.xy=np.vstack((self.x, self.y)).T #tri = Delaunay(self.xy) #tris =mtri.Triangulation(self.x, self.y) #self.triangles = tris.triangles #self.ax.tricontour(triangles = self.triangles, Z=self.z)#, cmap=plt.cm.Greys_r, antialiased=False) #self.surf = self.ax. #self.triangles = tri.simplices #mask = [s] self.surf = plt.tripcolor( self.x, self.y, self.triangles, facecolors=self.triangles[:, 0] ) #facecolours = self.triangles[:,0], edgecolors = 'k')#, cmap=plt.cm.Greys_r, antialiased=False) #self.surf = self.ax.plot_trisurf(self.x,self.y,self.z, triangles=sph.ch.simplices, cmap=plt.cm.Greys_r, alpha = 1) #self.surf.set_array(colours) #sph.icosahedron_vertices=np.asarray(sph.icosahedron_vertices) #self.ax.scatter(sph.icosahedron_vertices[:,0],sph.icosahedron_vertices[:,1], sph.icosahedron_vertices[:,2], c='red') plt.show() return self.surf, self.fig
def plot_sol(args, name, vmin=None, vmax=None): path = args.root_path + '/' + args.solutions_path + \ '/dolfin/' + name + '000000.vtu' x, u, tri = get_topology(path) colors = u fig = plt.figure(figsize=(8, 8)) plt.gca().set_aspect('equal') plt.axis('off') # shading='gouraud' tpc = plt.tripcolor(x[:, 0], x[:, 1], tri, colors, shading='flat', vmin=vmin, vmax=vmax) cb = plt.colorbar(tpc, aspect=20, shrink=0.5) cb.ax.tick_params(labelsize=20) fig.savefig(args.root_path + '/images/dolfin/' + name + '.png', bbox_inches='tight')
def plot(f, is_accurate, to_save): n = mesh.num_vertices() d = mesh.geometry().dim() mesh_coordinates = mesh.coordinates().reshape((n, d)) triangles = np.asarray([cell.entities(0) for cell in cells(mesh)]) triangulation = tri.Triangulation(mesh_coordinates[:, 0], mesh_coordinates[:, 1], triangles) fig, ax = plt.subplots() zfaces = np.asarray([f(cell.midpoint()) for cell in cells(mesh)]) ax_plot = plt.tripcolor(triangulation, facecolors=zfaces, edgecolors='k') fig.colorbar(ax_plot, ax=ax) if is_accurate: plt.title('Точное U') if to_save: plt.savefig('accurate.png') else: plt.title('Вычисленное U') if to_save: plt.savefig('calculated.png') plt.close() return fig
def plot_component(mesh, u, component): """ plots a single component of a vector field as a heat maps """ try: w0 = u.compute_vertex_values(mesh) except AttributeError: uu = project(u) w0 = uu.compute_vertex_values(mesh) n = mesh.num_vertices() start = component*n stop = (component+1)*n tt = w0[start:stop] top = max(tt) bottom = min(tt) fig = plt.figure() cax = plt.tripcolor(mesh2triang(mesh), tt, cmap = cm.coolwarm) plt.xlabel('x [$\mu$m]', fontsize=18) plt.ylabel('y [$\mu$m]', fontsize=18) plt.colorbar() plt.tight_layout() plt.tick_params(labelsize=16) plt.show() return fig
def plot_results(self, soln, okada_soln): pts, tris = self.all_mesh est = self.get_pt_soln(soln) vmax = np.max(okada_soln) for d in range(3): plt.figure() plt.tripcolor( pts[:, 0], pts[:, 1], tris, est[:, d], #shading='gouraud', cmap='PuOr', vmin=-vmax, vmax=vmax) plt.title("u " + ['x', 'y', 'z'][d]) plt.colorbar() for d in range(3): plt.figure() plt.tripcolor( pts[:, 0], pts[:, 1], tris, okada_soln[:, d], #shading='gouraud', cmap='PuOr', vmin=-vmax, vmax=vmax) plt.title("Okada u " + ['x', 'y', 'z'][d]) plt.colorbar() for d in range(3): plt.figure() plt.tripcolor( pts[:, 0], pts[:, 1], tris, okada_soln[:, d] - est[:, d], #shading='gouraud', cmap='PuOr') plt.title("Diff u " + ['x', 'y', 'z'][d]) plt.colorbar() plt.show()
sio.savemat('data/misc/fishcage/cage_elements_sfm6_musq2.mat',mdict=tempdic) np.savetxt('data/misc/fishcage/cage_elements_sfm6_musq2.dat',newhost+1,fmt='%i') drag=np.zeros([newhost.shape[0],])+0.6 depth=np.zeros([newhost.shape[0],])+10 fvcom_savecage('data/misc/fishcage/sfm6_musq2_cage.dat',newhost+1,drag,depth) trihost=np.zeros([data['uvnodell'].shape[0],]) trihost[newhost]=1 f=plt.figure() ax=f.add_axes([.125,.1,.775,.8]) triax=plt.tripcolor(data['trigrid'],trihost) ax.triplot(data['trigrid'],lw=.2) region={} region['region']=np.array([-66.925, -66.8,45.0,45.075]) prettyplot_ll(ax,setregion=region,grid=True) plt.title('Locations with cages') #eidx=get_elements(data,region) #for ele in eidx: #ax.text(data['uvnodell'][ele,0],data['uvnodell'][ele,1],"{}".format(ele+1)) f.savefig(savepath + 'cage_host_locations_new.png',dpi=2400) plt.close(f) remove=np.array([7090,7210,7209,6970,7211,19545,16462,25848,25889,25887,25886,
dmed = (mesh.hmax() + mesh.hmin()) / 2 Xn = nodes(coord) Xn.set_neighborhood(nei) # Number of subdomains nd = 10 K = dok_matrix((Xn.size, Xn.size), dtype=np.complex) k = 2 * np.pi f = np.zeros(Xn.size, dtype=np.complex) A, f = assemble(Xn, k) u_d = spsolve(A, f) triang = mesh2triang(mesh) plt.gca().set_aspect('equal') plt.tripcolor(triang, np.real(u_d), shading='gouraud') plt.show() dx = nd ovl = 0.1 list_mesh = submeshes(mesh, nd, dx, ovl, Verbose=False) r, rd = indices(list_mesh, mesh) R = [] D = [] K = [] Kinv = [] for j in range(nd): Ri, Di = restriction(len(r[j]), mt, r[j], rd) submesh = list_mesh[j] nei = connect(submesh)
import random import matplotlib.pyplot as plot import matplotlib.tri as tri count = 100 X = [random.random() for i in range(count)] Y = [random.random() for i in range(count)] Z = [0.] * count triangles = tri.Triangulation(X, Y) plot.tripcolor(triangles, Z, edgecolors='w') plot.show()
plt.title("Caso 2") plt.ylabel("Temperatura") plt.xlabel("Tiempo") plt.legend( loc ='best') plt.savefig('C2_Tpromedio.png') plt.close() C1_ab_xyt = np.genfromtxt("C1_abiertas_x_y_T.dat",comments='T') n=441; plt.tripcolor(C1_ab_xyt[0:n+1,0],C1_ab_xyt[0:n+1,1],C1_ab_xyt[0:n+1,2]) plt.title("Caso 1-Abiertas-T 0 ") plt.ylabel("Y") plt.xlabel("X") plt.colorbar() plt.savefig('C1_ab_T0.png') plt.close() plt.tripcolor(C1_ab_xyt[n+1:2*n+1,0],C1_ab_xyt[n+1:2*n+1,1],C1_ab_xyt[n+1:2*n+1,2]) plt.title("Caso 1-Abiertas-T 100 ") plt.ylabel("Y") plt.xlabel("X") plt.colorbar() plt.savefig('C1_ab_T2.png') plt.close()
host_lt_depth=np.where((data['uvh'][newhost]<=maxdepth) & (data['uvh'][newhost]>=mindepth))[0] newhostbool=np.zeros(shape=newhost.shape,dtype=bool) newhostbool[host_lt_depth]=True newhost=newhost[host_lt_depth.flatten()] tempdic={} tempdic['kelp_elements']=newhost #sio.savemat('kelp_elements_kit4.mat',mdict=tempdic) np.savetxt('data/grid_stuff/kelpnodes_'+grid+'.dat',newhost+1,fmt='%i') drag=np.zeros([newhost.shape[0],])+0.018 depth=np.zeros([newhost.shape[0],])+40 fvcom_savecage('data/cage_files/'+grid+'_cage_'+("%d"%mindepth)+'m_'+("%d"%maxdepth)+'m.dat',newhost+1,drag,depth) trihost=np.zeros([data['uvnodell'].shape[0],]) trihost[newhost]=1 plt.close() plt.tripcolor(data['trigrid'],trihost) plt.colorbar() plt.grid() plt.axis(region['region']) plt.title('Locations with kelp') plt.savefig(savepath +grid+'_'+regionname+ 'kelp_host_locations_3.png',dpi=1200) plt.close()
# -*- coding: utf-8 -*- """ Created on Sun Sep 9 22:35:18 2018 @author: zdlls """ import matplotlib.pyplot as plt import numpy as np data = np.loadtxt('waveguide.txt') x = data[:, 0] y = data[:, 1] z = data[:, 2] plt.tripcolor(x, y, z) plt.show()
fldvplot[fldspeedplot <= .01] = np.nan Q = plt.quiver(data['uvnodell'][sidx, 0], data['uvnodell'][sidx, 1], flduplot[sidx], fldvplot[sidx], angles='xy', scale_units='xy', scale=10) qk = plt.quiverkey(Q, .2, 1.05, 0.25, '0.25 ms^-1', labelpos='W') plt.grid() plt.axis(region['region']) plt.gca().get_xaxis().get_major_formatter().set_useOffset(False) plt.savefig(savepath + name + '_' + regionname + '_vector_maxfld_s_' + ("%d" % spacing) + '.png', dpi=1200) #plot max speed plt.close() plt.tripcolor( data['trigrid'], np.max(np.sqrt(newu**2 + newv**2), axis=0), vmin=1.15 * np.min(np.max(np.sqrt(newu[:, sidx]**2 + newv[:, sidx]**2), axis=0)), vmax=.85 * np.max(np.max(np.sqrt(newu[:, sidx]**2 + newv[:, sidx]**2), axis=0))) plt.colorbar() plt.grid() plt.axis(region['region']) plt.gca().get_xaxis().get_major_formatter().set_useOffset(False) plt.savefig(savepath + name + '_' + regionname + '_maxspeed.png', dpi=1200)
def plotstate(Mesh, U, field, fname, clim1, clim2, color, plotExact, plotError): V = Mesh['V'] E = Mesh['E'] BE = Mesh['BE'] #f = plt.figure(figsize=(12,6)) F = pu.getField(U, field) if((plotExact == True) or (plotError == True)): Exact = F s = field.lower() if (s == 'pressure'): Exact = pu.p_a(V[:,0], V[:,1]) #F = ((pr - F)/pr)*100. elif (s == 'density'): Exact = pu.rho_a(V[:,0], V[:,1]) #F = ((rho_a - F)/rho_a)*100. elif (s == 'xmomentum'): Exact = pu.rho_a(V[:,0], V[:,1])*pu.u_a(V[:,0], V[:,1]) #F = ((ru_a - F)/ru_a)*100. elif (s == 'ymomentum'): Exact = pu.rho_a(V[:,0], V[:,1])*pu.v_a(V[:,0], V[:,1]) #F = ((rv_a - F)/rv_a)*100. elif (s == 'energy'): Exact = pu.E_a(V[:,0], V[:,1]) #F = ((E_a - F)/E_a)*100. elif (s == 'renergy'): Exact = pu.rE_a(V[:,0], V[:,1]) #F = ((rE_a - F)/rE_a)*100. elif (s == 'xvelocity'): Exact = pu.u_a(V[:,0], V[:,1]) #F = ((u_a - F)/u_a)*100. elif (s == 'yvelocity'): Exact = pu.v_a(V[:,0], V[:,1]) #F = ((v_a - F)/v_a)*100. if(plotError == True): F = np.abs(Exact - F) #F = ((Exact - F)/Exact)*100. if(plotExact == True): F = Exact clim1 = np.min(F) clim2 = np.max(F) if(F.shape[0] == V.shape[0]): plt.tripcolor(V[:,0], V[:,1], F, triangles=E, shading='gouraud', edgecolors=color, vmin=clim1, vmax=clim2, linewidth=1) #plt.tripcolor(V[:,0], V[:,1], F, triangles=E, shading='flat', edgecolors=color, vmin=clim1, vmax=clim2, linewidth=1) else: plt.tripcolor(V[:,0], V[:,1], triangles=E, facecolors=F, shading='flat', vmin=clim1, vmax=clim2, linewidth=1) for i in range(len(BE)): x = [V[BE[i,0],0], V[BE[i,1],0]] y = [V[BE[i,0],1], V[BE[i,1],1]] plt.plot(x, y, '-', linewidth=2, color='black') dosave = (len(fname) != 0) plt.axis('equal') #plt.axis([-100, 100,-100, 100]) #plt.axis([-0.5, 1.5, -0.75, 1.5]) #plt.colorbar() #plt.clim(0, 0.7) #plt.clim(9, 12) if(plotError == True): plt.title(field+' error', fontsize=16) elif(plotExact == True): plt.title(field+' exact', fontsize=16) else: plt.title(field, fontsize=16)
# differentiate the posterior with respect to x derivative_gp = posterior_gp.differentiate((1, 0)) # evaluate the posterior and posterior derivative at the interpolation # points. calling the GaussianProcess instances will return their mean # and standard deviation at the provided points. post_mean, post_std = posterior_gp(xitp) diff_mean, diff_std = derivative_gp(xitp) ## Plotting # plot the true function utrue = true_function(xitp) plt.figure(1) plt.title('True function') p = plt.tripcolor(xitp[:, 0], xitp[:, 1], utrue, cmap='viridis') plt.xlim(0, 1) plt.ylim(0, 1) plt.colorbar(p) plt.tight_layout() # plot the interpolant plt.figure(2) plt.title('RBF interpolant (dots are observations)') p = plt.tripcolor(xitp[:, 0], xitp[:, 1], post_mean, cmap='viridis') # plot the observations plt.scatter(xobs[:, 0], xobs[:, 1], c=uobs, s=40, edgecolor='k',
t = t_start i = 0 while t < t_end: print 'time =', t u0.assign(u) solve(a == L, u, bc) plt.figure() zfaces = numpy.asarray([u(cell.midpoint()) for cell in cells(mesh)]) plt.tripcolor(triangulation, facecolors=zfaces, edgecolors='k', vmin=0, vmax=2) plt.colorbar() kurs = "result/%i.png" % i plt.savefig(kurs, format='png') plt.close() TotFlux = assemble(div(flux(u)) * dx) Totu = assemble(u * dx) u_val[i, 0] = t u_val[i, 1] = Totu u_val[i, 2] = TotFlux print 'time =', t