def plotWeightChanges(): if f.usestdp: # create plot figh = figure(figsize=(1.2*8,1.2*6)) figh.subplots_adjust(left=0.02) # Less space on left figh.subplots_adjust(right=0.98) # Less space on right figh.subplots_adjust(top=0.96) # Less space on bottom figh.subplots_adjust(bottom=0.02) # Less space on bottom figh.subplots_adjust(wspace=0) # More space between figh.subplots_adjust(hspace=0) # More space between h = axes() # create data matrix wcs = [x[-1][-1] for x in f.allweightchanges] # absolute final weight wcs = [x[-1][-1]-x[0][-1] for x in f.allweightchanges] # absolute weight change pre,post,recep = zip(*[(x[0],x[1],x[2]) for x in f.allstdpconndata]) ncells = int(max(max(pre),max(post))+1) wcmat = zeros([ncells, ncells]) for iwc,ipre,ipost,irecep in zip(wcs,pre,post,recep): wcmat[int(ipre),int(ipost)] = iwc *(-1 if irecep>=2 else 1) # plot imshow(wcmat,interpolation='nearest',cmap=bicolormap(gap=0,mingreen=0.2,redbluemix=0.1,epsilon=0.01)) xlabel('post-synaptic cell id') ylabel('pre-synaptic cell id') h.set_xticks(f.popGidStart) h.set_yticks(f.popGidStart) h.set_xticklabels(f.popnames) h.set_yticklabels(f.popnames) h.xaxif.set_ticks_position('top') xlim(-0.5,ncells-0.5) ylim(ncells-0.5,-0.5) clim(-abs(wcmat).max(),abs(wcmat).max()) colorbar()
def plot_field(self,x,y,u=None,v=None,F=None,contour=False,outdir=None,plot='quiver',figname='_field',format='eps'): outdir = self.set_dir(outdir) p = 64 if F is None: F=self.calc_F(u,v) plt.close('all') plt.figure() #fig, axes = plt.subplots(nrows=1) if contour: plt.hold(True) plt.contourf(x,y,F) if plot=='quiver': plt.quiver(x[::p],y[::p],u[::p],v[::p],scale=0.1) if plot=='pcolor': plt.pcolormesh(x[::4],y[::4],F[::4],cmap=plt.cm.Pastel1) plt.colorbar() if plot=='stream': speed = F[::16] plt.streamplot(x[::16], y[::16], u[::16], v[::16], density=(1,1),color='k') plt.xlabel('$x$ (a.u.)') plt.ylabel('$y$ (a.u.)') plt.savefig(os.path.join(outdir,figname+'.'+format),format=format,dpi=320,bbox_inches='tight') plt.close()
def plot_confusion_matrix(cm, title='', cmap=plt.cm.Blues): #print cm #display vehicle, idle, walking accuracy respectively #display overall accuracy print type(cm) # plt.figure(index plt.imshow(cm, interpolation='nearest', cmap=cmap) #plt.figure("") plt.title("Confusion Matrix") plt.colorbar() tick_marks = [0,1,2] target_name = ["driving","idling","walking"] plt.xticks(tick_marks,target_name,rotation=45) plt.yticks(tick_marks,target_name,rotation=45) print len(cm[0]) for i in range(0,3): for j in range(0,3): plt.text(i,j,str(cm[i,j])) plt.tight_layout() plt.ylabel("Actual Value") plt.xlabel("Predicted Outcome")
def plot(self, normalized=False, backend=None, ax=None, **kwargs): """ Plots confusion matrix """ df = self.to_dataframe(normalized) try: cmap = kwargs['cmap'] except: cmap = plt.cm.gray_r title = self.title if normalized: title += " (normalized)" if backend is None: backend = self.backend if backend == Backend.Matplotlib: #if ax is None: fig, ax = plt.subplots(figsize=(9, 8)) plt.imshow(df, cmap=cmap, interpolation='nearest') # imshow / matshow ax.set_title(title) tick_marks_col = np.arange(len(df.columns)) tick_marks_idx = tick_marks_col.copy() ax.set_yticks(tick_marks_idx) ax.set_xticks(tick_marks_col) ax.set_xticklabels(df.columns, rotation=45, ha='right') ax.set_yticklabels(df.index) ax.set_ylabel(df.index.name) ax.set_xlabel(df.columns.name) (N_min, N_max) = (0, self.max()) if N_max > COLORBAR_TRIG: plt.colorbar() # Continuous colorbar else: # Discrete colorbar ax2 = fig.add_axes([0.93, 0.1, 0.03, 0.8]) bounds = np.arange(N_min, N_max + 2, 1) norm = mpl.colors.BoundaryNorm(bounds, cmap.N) cb = mpl.colorbar.ColorbarBase(ax2, cmap=cmap, norm=norm, spacing='proportional', ticks=bounds, boundaries=bounds, format='%1i') return(ax) elif backend == Backend.Seaborn: import seaborn as sns ax = sns.heatmap(df, **kwargs) return(ax) # You should test this yourself # because I'm facing an issue with Seaborn under Mac OS X (2015-04-26) # RuntimeError: Cannot get window extent w/o renderer #sns.plt.show() else: raise(NotImplementedError("backend=%r not allowed" % backend))
def plot_bernoulli_matrix(self, show_npfs=False): """ Plot the heatmap of the Bernoulli matrix @self @show_npfs - Highlight NPFS detections [Boolean] """ matrix = self.Bernoulli_matrix if show_npfs == False: plot = plt.imshow(matrix) plot.set_cmap('hot') plt.colorbar() plt.xlabel("Bootstraps") plt.ylabel("Feature") plt.show() else: for i in self.selected_features: for k in range(len(matrix[i])): matrix[i,k] = .5 plot = plt.imshow(matrix) plot.set_cmap('hot') plt.xlabel("Bootstraps") plt.ylabel("Feature") plt.colorbar() plt.show() return None
def test_likelihood_evaluator3(): tr = template.TemplateRenderCircleBorder() tr.set_params(14, 6, 4) t1 = tr.render(0, np.pi/2) img = np.zeros((240, 320), dtype=np.uint8) env = util.Environmentz((1.5, 2.0), (240, 320)) le2 = likelihood.LikelihoodEvaluator3(env, tr) img[(120-t1.shape[0]/2):(120+t1.shape[0]/2), (160-t1.shape[1]/2):(160+t1.shape[1]/2)] += t1 *255 pylab.subplot(1, 2, 1) pylab.imshow(img, interpolation='nearest', cmap=pylab.cm.gray) state = np.zeros(1, dtype=util.DTYPE_STATE) xvals = np.linspace(0, 2., 100) yvals = np.linspace(0, 1.5, 100) res = np.zeros((len(yvals), len(xvals)), dtype=np.float32) for yi, y in enumerate(yvals): for xi, x in enumerate(xvals): state[0]['x'] = x state[0]['y'] = y state[0]['theta'] = np.pi / 2. res[yi, xi] = le2.score_state(state, img) pylab.subplot(1, 2, 2) pylab.imshow(res) pylab.colorbar() pylab.show()
def plot_grid_experiment_results(grid_results, params, metrics): global plt params = sorted(params) grid_params = grid_results.grid_params plt.figure(figsize=(8, 6)) for metric in metrics: grid_params_shape = [len(grid_params[k]) for k in sorted(grid_params.keys())] params_max_out = [(1 if k in params else 0) for k in sorted(grid_params.keys())] results = np.array([e.results.get(metric, 0) for e in grid_results.experiments]) results = results.reshape(*grid_params_shape) for axis, included_in_params in enumerate(params_max_out): if not included_in_params: results = np.apply_along_axis(np.max, axis, results) print results params_shape = [len(grid_params[k]) for k in sorted(params)] results = results.reshape(*params_shape) if len(results.shape) == 1: results = results.reshape(-1,1) import matplotlib.pylab as plt #f.subplots_adjust(left=.2, right=0.95, bottom=0.15, top=0.95) plt.imshow(results, interpolation='nearest', cmap=plt.cm.hot) plt.title(str(grid_results.name) + " " + metric) if len(params) == 2: plt.xticks(np.arange(len(grid_params[params[1]])), grid_params[params[1]], rotation=45) plt.yticks(np.arange(len(grid_params[params[0]])), grid_params[params[0]]) plt.colorbar() plt.show()
def plotMatrix(data): fig = plt.figure() ax = fig.add_subplot(1,1,1) ax.set_aspect('equal') plt.imshow(data, interpolation='nearest', cmap=plt.cm.ocean) plt.colorbar() plt.show()
def XXtest5_regrid(self): srcF = cdms2.open(sys.prefix + \ '/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc') so = srcF('so')[0, 0, ...] clt = cdms2.open(sys.prefix + '/sample_data/clt.nc')('clt') dstData = so.regrid(clt.getGrid(), regridTool = 'esmf', regridMethod='conserve') if self.pe == 0: dstDataMask = (dstData == so.missing_value) dstDataFltd = dstData * (1 - dstDataMask) zeroValCnt = (dstData == 0).sum() if so.missing_value > 0: dstDataMin = dstData.min() dstDataMax = dstDataFltd.max() else: dstDataMin = dstDataFltd.min() dstDataMax = dstData.max() zeroValCnt = (dstData == 0).sum() print 'Number of zero valued cells', zeroValCnt print 'min/max value of dstData: %f %f' % (dstDataMin, dstDataMax) self.assertLess(dstDataMax, so.max()) if False: pylab.figure(1) pylab.pcolor(so, vmin=20, vmax=40) pylab.colorbar() pylab.title('so') pylab.figure(2) pylab.pcolor(dstData, vmin=20, vmax=40) pylab.colorbar() pylab.title('dstData')
def test2_varRegrid(self): print print 'test2_varRegrid' srcF = cdms2.open(sys.prefix + \ '/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc') so = srcF('so')[0, 0, ...] clt = cdms2.open(sys.prefix + '/sample_data/clt.nc')('clt') diag = {'srcAreas': None, 'dstAreas': None, 'srcAreaFractions': None, 'dstAreaFractions': None} soInterp = so.regrid(clt.getGrid(), regridTool = 'esmf', regridMethod='conserve', diag = diag) if self.pe == 0: totSrcArea = diag['srcAreas'].sum() totDstArea = diag['dstAreas'].sum() totSrcFrac = diag['srcAreaFractions'].sum() self.assertEqual(numpy.isnan(totSrcFrac).sum(), 0) self.assertLess(abs(totSrcArea - 4*pi)/(4*pi), 0.02) self.assertLess(abs(totDstArea - 4*pi)/(4*pi), 0.01) soMass = (so*diag['srcAreas']).sum() inMass = (soInterp*diag['dstAreas']).sum() print soMass, inMass diff = abs(soMass - inMass)/soMass self.assertLess(diff, 7.e-7) if False: pylab.subplot(1, 2, 1) pylab.pcolor(so, vmin = 20, vmax = 40) pylab.colorbar() pylab.title('so') pylab.subplot(1, 2, 2) pylab.pcolor(soInterp, vmin = 20, vmax = 40) pylab.colorbar() pylab.title('soInterp')
def plotscalefactors(self): ''' Plots the distribution of scalefactors between consecutive images. This is to check manually that the hdr image assembly is done correctly. ''' import matplotlib.pylab as plt print('Scalefactors for HDR-assembling are', self.scalefactors) print('Standard deviations for Scalefactors are', self.scalefactorsstd) # Plots the scalefactordistribution and scalefactors for each pixelvalue self.scaleforpix = range(len(self.raw)) for n in range(len(self.raw) - 1): A = self.getimgquotient(n) B = self._getrealimg(n + 1) fig = plt.figure() plt.xlabel('x [pixel]') plt.ylabel('y [pixel]') fig.set_size_inches(10, 10) plt.imshow(A) plt.clim([0.95 * A[np.isfinite(A)].min(), 1.05 * A[np.isfinite(A)].max()]) plt.colorbar() fig = plt.figure() linplotdata = np.array([B[np.isfinite(B)].flatten(), A[np.isfinite(B)].flatten()]) plt.plot(linplotdata[0, :], linplotdata[1, :], 'ro')
def plot(x,y,field,filename,c=200): plt.figure() # define grid. xi = np.linspace(min(x),max(x),100) yi = np.linspace(min(y),max(y),100) # grid the data. si_lin = griddata((x, y), field, (xi[None,:], yi[:,None]), method='linear') si_cub = griddata((x, y), field, (xi[None,:], yi[:,None]), method='linear') print np.min(field) print np.max(field) plt.subplot(211) # contour the gridded data, plotting dots at the randomly spaced data points. CS = plt.contour(xi,yi,si_lin,c,linewidths=0.5,colors='k') CS = plt.contourf(xi,yi,si_lin,c,cmap=plt.cm.jet) plt.colorbar() # draw colorbar # plot data points. # plt.scatter(x,y,marker='o',c='b',s=5) plt.xlim(min(x),max(x)) plt.ylim(min(y),max(y)) plt.title('Lineaarinen interpolointi') #plt.tight_layout() plt.subplot(212) # contour the gridded data, plotting dots at the randomly spaced data points. CS = plt.contour(xi,yi,si_cub,c,linewidths=0.5,colors='k') CS = plt.contourf(xi,yi,si_cub,c,cmap=plt.cm.jet) plt.colorbar() # draw colorbar # plot data points. # plt.scatter(x,y,marker='o',c='b',s=5) plt.xlim(min(x),max(x)) plt.ylim(min(y),max(y)) plt.title('Kuubinen interpolointi') plt.savefig(filename)
def test2_3x4_to_5x7_cart(self): # Test non-periodic grid returning double grid resolution roESMP = CdmsRegrid(self.fromGrid3x4, self.toGrid5x7, dtype = self.data3x4.dtype, srcGridMask = self.data3x4.mask, regridTool = 'ESMP', periodicity = 0, regridMethod = 'Conserve', coordSys = 'cart') diag = {'srcAreas':0, 'dstAreas':0, 'srcAreaFractions':0, 'dstAreaFractions':0} ESMP5x7 = roESMP(self.data3x4, diag = diag) dstMass = (ESMP5x7 * diag['dstAreas']).sum() srcMass = (self.data3x4 * diag['srcAreas'] \ * diag['srcAreaFractions']).sum() if False: pylab.figure(1) pylab.pcolor(self.data3x4) pylab.colorbar() pylab.title('original self.data3x4') pylab.figure(2) pylab.pcolor(ESMP5x7) pylab.colorbar() pylab.title('interpolated ESMP5x7') self.assertLess(abs(srcMass - dstMass), self.eps) self.assertEqual(self.data3x4[0,0], ESMP5x7[0,0]) self.assertEqual(1.0, ESMP5x7[0,0]) self.assertEqual(0.25, ESMP5x7[1,1]) self.assertEqual(0.0, ESMP5x7[2,2])
def perform_interpolation(self,dataextrap,regridme,field_src,field_target,use_locstream): data = self.allocate() if self.geometry == 'surface': for kz in _np.arange(self.nz): field_src.data[:] = dataextrap[kz,:,:].transpose() field_target = regridme(field_src, field_target) if use_locstream: if self.nx == 1: data[kz,:,0] = field_target.data.copy() elif self.ny == 1: data[kz,0,:] = field_target.data.copy() else: data[kz,:,:] = field_target.data.transpose()[self.jmin:self.jmax+1, \ self.imin:self.imax+1] if self.debug and kz == 0: data_target_plt = _np.ma.masked_values(data[kz,:,:],self.xmsg) #data_target_plt = _np.ma.masked_values(field_target.data,self.xmsg) _plt.figure() ; _plt.contourf(data_target_plt[:,:],40) ; _plt.colorbar() ; _plt.title('regridded') ; _plt.show() elif self.geometry == 'line': field_src.data[:] = dataextrap[:,:].transpose() field_target = regridme(field_src, field_target) if use_locstream: data[:,:] = _np.reshape(field_target.data.transpose(),(self.ny,self.nx)) else: data[:,:] = field_target.data.transpose()[self.jmin:self.jmax+1,self.imin:self.imax+1] return data
def reconstructContactMap(map, datavec): """ Plots a given vector as a contact map Parameters ---------- map : np.ndarray 2D The map from a MetricData object datavec : np.ndarray The data we want to plot in a 2D map """ map = np.array(map, dtype=int) atomidx = np.unique(map.flatten()).astype(int) mask = np.zeros(max(atomidx)+1, dtype=int) mask[atomidx] = range(len(atomidx)) # Create a new map which maps from vector indexes to matrix indexes newmap = np.zeros(np.shape(map), dtype=int) newmap[:, 0] = mask[map[:, 0]] newmap[:, 1] = mask[map[:, 1]] contactmap = np.zeros((len(atomidx), len(atomidx))) for i in range(len(datavec)): contactmap[newmap[i, 0], newmap[i, 1]] = datavec[i] contactmap[newmap[i, 1], newmap[i, 0]] = datavec[i] from matplotlib import pylab as plt plt.imshow(contactmap, interpolation='nearest', aspect='equal') plt.colorbar() #plt.axis('off') #plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') #plt.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') plt.show()
def testSingleTimeSingleElev(self): """ Interpolate over one level/time """ f = cdms2.open(sys.prefix + '/sample_data/clt.nc') clt = f('clt') v = f('v')[0,0,...] srcGrid = v.getGrid() dstGrid = clt.getGrid() ro = CdmsRegrid(srcGrid = srcGrid, dstGrid = dstGrid, dtype = v.dtype) vInterp = ro(v) print 'min/max of v: %f %f' % (v.min(), v.max()) print 'min/max of vInterp: %f %f' % (vInterp.min(), vInterp.max()) if False: pl.figure() pl.pcolor(vInterp, vmin=-20, vmax=20) pl.title('testSingleTimeSingleElev: vInterp') pl.colorbar()
def drown_field(self,data,mask,drown): ''' drown_field is a wrapper around the fortran code fill_msg_grid. depending on the output geometry, applies land extrapolation on 1 or N levels''' if self.geometry == 'surface': for kz in _np.arange(self.nz): tmpin = data[kz,:,:].transpose() if self.debug and kz == 0: tmpin_plt = _np.ma.masked_values(tmpin,self.xmsg) _plt.figure() ; _plt.contourf(tmpin_plt.transpose(),40) ; _plt.colorbar() ; _plt.title('normalized before drown') if drown == 'ncl': tmpout = _fill.mod_poisson.poisxy1(tmpin,self.xmsg, self.guess, self.gtype, \ self.nscan, self.epsx, self.relc) elif drown == 'sosie': tmpout = _mod_drown_sosie.mod_drown.drown(self.kew,tmpin,mask[kz,:,:].T,\ nb_inc=200,nb_smooth=40) data[kz,:,:] = tmpout.transpose() if self.debug and kz == 0: _plt.figure() ; _plt.contourf(tmpout.transpose(),40) ; _plt.colorbar() ; _plt.title('normalized after drown') _plt.show() elif self.geometry == 'line': tmpin = data[:,:].transpose() if drown == 'ncl': tmpout = _fill.mod_poisson.poisxy1(tmpin,self.xmsg, self.guess, self.gtype, \ self.nscan, self.epsx, self.relc) elif drown == 'sosie': tmpout = _mod_drown_sosie.mod_drown.drown(self.kew,tmpin,mask[:,:].T,\ nb_inc=200,nb_smooth=40) data[:,:] = tmpout.transpose() return data
def __init__ (self, im, location, fprefix='./', wrpng=1, pltmoon=0): self._wrpng = wrpng; self._im = im; self._fprefix = fprefix; self._pltmoon = pltmoon; self._loc = location; # Available locations if self._loc.lower() == 'lofar': self._obssite = ephem.Observer(); self._obssite.pressure = 0; # To prevent refraction corrections. self._obssite.lon, self._obssite.lat = '6.869837540','52.915122495'; # CS002 on LOFAR elif self._loc.lower() == 'dwingeloo': self._obssite = ephem.Observer(); self._obssite.pressure = 0; # To prevent refraction corrections. self._obssite.lon, self._obssite.lat = '6.396297','52.812204'; # Dwingeloo telescope else: print 'Unknown observatory site!' if self._pltmoon == 1: self._moon = ephem.Moon(); self._casa = ephem.readdb('Cas-A,f|J, 23:23:26.0, 58:48:00,99.00,2000'); if matplotFound ==0 & ephemFound == 0: print 'Matplotlib or pyephem not found! PNG Images written to disk.' self._wrpng = 1; else: self._imgplt = plt.imshow (abs(self._im._skymap[:,:]), extent = [self._im._l[0], self._im._l[-1], self._im._m[0], self._im._m[-1]]); plt.colorbar();
def generate_matrix_visualization(known_words, bookmark_words): m = [] for i in range(0,100): m.append([]) for j in range (0, 100): if (i*100+j) in bookmark_words: m[i].append(0.65) elif (i*100+j) in known_words: m[i].append(0.4) else: m[i].append(0.2) m.reverse() # we need this next line to scale the color scheme m[0][0]=0 matrix = numpy.matrix(m) fig = plt.figure() ax = fig.add_subplot(1,1,1) ax.set_aspect('equal') plt.imshow(matrix, interpolation='none', extent=[0,10000,0,10000]) frame = pylab.gca() frame.axes.get_xaxis().set_ticks([]) #plt.axis([0,10000,0,10000]) plt.ylabel('Rank') plt.title('Encountered Ranked Words by User') plt.colorbar() plt.show()
def generate_matrix_visualization(known_words, bookmark_words): m = [] for i in range(0,100): m.append([]) for j in range (0, 100): if (i*100+j) in bookmark_words: m[i].append(0.65) elif (i*100+j) in known_words: m[i].append(0.4) else: m[i].append(0.2) m.reverse() # we need this next line to scale the color scheme m[0][0]=0 matrix = numpy.matrix(m) fig = plt.figure() ax = fig.add_subplot(1,1,1) ax.set_aspect('equal') plt.imshow(matrix, interpolation='none') plt.set_cmap('hot') plt.colorbar() plt.show()
def showladderpca(self): import mdp from matplotlib import pylab as plt import pprint import math cerr('calculating PCA & plotting') peak_sizes = sorted(list([ x.rtime for x in self.alleles ])) #peak_sizes = sorted( peak_sizes )[:-5] #pprint.pprint(peak_sizes) #comps = algo.simple_pca( peak_sizes ) #algo.plot_pca(comps, peak_sizes) from fatools.lib import const std_sizes = const.ladders['LIZ600']['sizes'] x = std_sizes y = [ x * 0.1 for x in peak_sizes ] D = np.zeros( (len(y), len(x)) ) for i in range(len(y)): for j in range(len(x)): D[i,j] = math.exp( ((x[j] - y[i]) * 0.001) ** 2 ) pprint.pprint(D) im = plt.imshow(D, interpolation='nearest', cmap='Reds') plt.gca().invert_yaxis() plt.xlabel("STD") plt.ylabel("PEAK") plt.grid() plt.colorbar() plt.show()
def plot_prof(obj): '''Function that plots a vertical profile of scattering from TOC to BOC. Input: rt_layer instance object. Output: plot of scattering. ''' I = obj.Inodes[:,1,:] \ / -obj.mu_s y = np.linspace(obj.Lc, 0., obj.K+1) x = obj.views*180./np.pi xm = np.array([]) for i in np.arange(0,len(x)-1): nx = x[i] + (x[i+1]-x[i])/2. xm = np.append(xm,nx) xm = np.insert(xm,0,0.) xm = np.append(xm,180.) xx, yy = np.meshgrid(xm, y) plt.pcolormesh(xx,yy,I) plt.colorbar() plt.title('Canopy Fluxes') plt.xlabel('Exit Zenith Angle') plt.ylabel('Cumulative LAI (0=soil)') plt.arrow(135.,3.5,0.,-3.,head_width=5.,head_length=.2,\ fc='k',ec='k') plt.text(140.,2.5,'Downwelling Flux',rotation=90) plt.arrow(45.,.5,0.,3.,head_width=5.,head_length=.2,\ fc='k',ec='k') plt.text(35.,2.5,'Upwelling Flux',rotation=270) plt.show()
def plot_image(*positional_parameters,title="TITLE",xtitle=r"X",ytitle=r"Y",cmap=None,aspect=None,show=1): n_arguments = len(positional_parameters) if n_arguments == 1: z = positional_parameters[0] x = np.arange(0,z.shape[0]) y = np.arange(0,z.shape[0]) elif n_arguments == 2: z = positional_parameters[0] x = positional_parameters[1] y = positional_parameters[1] elif n_arguments == 3: z = positional_parameters[0] x = positional_parameters[1] y = positional_parameters[2] else: raise Exception("Bad number of inputs") fig = plt.figure() # cmap = plt.cm.Greys plt.imshow(z.T,origin='lower',extent=[x[0],x[-1],y[0],y[-1]],cmap=cmap,aspect=aspect) plt.colorbar() ax = fig.gca() ax.set_xlabel(xtitle) ax.set_ylabel(ytitle) plt.title(title) if show: plt.show() return fig
def plotConn(): # Create plot figh = figure(figsize=(8,6)) figh.subplots_adjust(left=0.02) # Less space on left figh.subplots_adjust(right=0.98) # Less space on right figh.subplots_adjust(top=0.96) # Less space on bottom figh.subplots_adjust(bottom=0.02) # Less space on bottom figh.subplots_adjust(wspace=0) # More space between figh.subplots_adjust(hspace=0) # More space between h = axes() totalconns = zeros(shape(f.connprobs)) for c1 in range(size(f.connprobs,0)): for c2 in range(size(f.connprobs,1)): for w in range(f.nreceptors): totalconns[c1,c2] += f.connprobs[c1,c2]*f.connweights[c1,c2,w]*(-1 if w>=2 else 1) imshow(totalconns,interpolation='nearest',cmap=bicolormap(gap=0)) # Plot grid lines hold(True) for pop in range(f.npops): plot(array([0,f.npops])-0.5,array([pop,pop])-0.5,'-',c=(0.7,0.7,0.7)) plot(array([pop,pop])-0.5,array([0,f.npops])-0.5,'-',c=(0.7,0.7,0.7)) # Make pretty h.set_xticks(range(f.npops)) h.set_yticks(range(f.npops)) h.set_xticklabels(f.popnames) h.set_yticklabels(f.popnames) h.xaxis.set_ticks_position('top') xlim(-0.5,f.npops-0.5) ylim(f.npops-0.5,-0.5) clim(-abs(totalconns).max(),abs(totalconns).max()) colorbar()
def plot_block( files, m, n ): """ - files is directory for cell - m starting index, n ending index Use pylab.imshow() to plot a frame (npy array). Note: The boundary should be removed, thus there will not be a halo """ #Get all frames if os.path.isdir (files): fdir = files + '/' dlist = os.listdir(fdir) frames = [] for f in dlist: if f.endswith('npy') and not os.path.isdir(fdir+f): frames.append(f) else: print 'Error - input is not a directory' return #Sort frames frames . sort(key=natural_key) stack = [] #load npy arrays for ind in xrange(len(frames)): if ind >= m and ind <= n: stack.append(numpy.load(files + frames[ind])) #Create 3d array d = numpy.dstack(stack) d = numpy.rollaxis(d,-1) fig = plt.figure() plt.title("RBC Stack") plt.imshow(d[1]) plt.colorbar() plt.show()
def validate(X_test, y_test, pipe, title, fileName): print('Test Accuracy: %.3f' % pipe.score(X_test, y_test)) y_predict = pipe.predict(X_test) confusion_matrix = np.zeros((9,9)) for p,r in zip(y_predict, y_test): confusion_matrix[p-1,r-1] = confusion_matrix[p-1,r-1] + 1 print (confusion_matrix) confusion_normalized = confusion_matrix.astype('float') / confusion_matrix.sum(axis=1)[:, np.newaxis] print (confusion_normalized) pylab.clf() pylab.matshow(confusion_normalized, fignum=False, cmap='Blues', vmin=0.0, vmax=1.0) ax = pylab.axes() ax.set_xticks(range(len(families))) ax.set_xticklabels(families, fontsize=4) ax.xaxis.set_label_position('top') ax.xaxis.set_ticks_position("top") ax.set_yticks(range(len(families))) ax.set_yticklabels(families, fontsize=4) pylab.title(title) pylab.colorbar() pylab.grid(False) pylab.grid(False) pylab.savefig(fileName, dpi=900)
def plot(rho, u, uLB, tau, rho_history, zdjecia, image, nx, maxIter ): # plt.figure(figsize=(15,15)) # plt.subplot(4, 1, 1) # plt.imshow(u[1,:,0:50],vmin=-uLB*.15, vmax=uLB*.15, interpolation='none')#,cmap=cm.seismic # plt.colorbar() plt.rcParams["figure.figsize"] = (15,15) plt.subplot(5, 1, 1) plt.imshow(sqrt(u[0]**2+u[1]**2),vmin=0, vmax=uLB*1.6)#,cmap=cm.seismic plt.colorbar() plt.title('tau = {:f}'.format(tau)) plt.subplot(5, 1, 2) plt.imshow(u[0,:,:30], interpolation='none')#,cmap=cm.seismicvmax=uLB*1.6, plt.colorbar() plt.title('tau = {:f}'.format(tau)) plt.subplot(5, 1, 3) plt.imshow(rho, interpolation='none' )#,cmap=cm.seismic plt.title('rho') plt.subplot(5, 1,4) plt.title(' history rho') plt.plot(linspace(0,len(rho_history),len(rho_history)),rho_history) plt.xlim([0,maxIter]) plt.subplot(5, 1,5) plt.title(' u0 middle develop') plt.plot(linspace(0,nx,len(u[0,20,:])), u[1,20,:]) plt.tight_layout() plt.savefig(path.join(zdjecia,'f{0:06d}.png'.format(image))) plt.clf();
def show_slice(data, slice_no=0, clim=None): """ Visualize the reconstructed slice. Parameters ----------- data : ndarray 3-D matrix of stacked reconstructed slices. slice_no : scalar, optional The index of the slice to be imaged. """ plt.figure(figsize=(7, 7)) if len(data.shape) is 2: plt.imshow(data, interpolation='none', cmap='gray') plt.colorbar() elif len(data.shape) is 3: plt.imshow(data[slice_no, :, :], interpolation='none', cmap='gray') plt.colorbar() if clim is not None: plt.clim(clim) plt.show()
def plot(coefs_files, digit=0, mixture=0, axis=0): import numpy as np import matplotlib.pylab as plt import amitgroup as ag for coefs_file in coefs_files: coefs_data = np.load(coefs_file) var = coefs_data['prior_var'] samples = coefs_data['samples'] llh_var = coefs_data['llh_var'] var_flat = ag.util.wavelet.smart_flatten(var[digit,mixture,axis]) last_i = len(var_flat)-1 plt.xlim((0, last_i)) #imdef = ag.util.DisplacementFieldWavelet((32, 32), 'db4', penalty=100 if len(coefs_files) == 1: add = "" else: add = " ({0})".format(coefs_file.name) plt.subplot(121) plt.semilogy(1/var_flat, label="ML"+add) plt.legend(loc=0) plt.xlabel('Coefficient') plt.ylabel('Precision $\lambda$') plt.xlim((0, 63)) plt.subplot(122) plt.imshow(1/llh_var[digit,mixture], interpolation='nearest') plt.xlabel("Likelihood precision $\lambda'$") plt.colorbar() plt.show()
def save_results(self, file_path_pattern): """file_path_pattern could be a dir or a pattern if it is a dir then /path/to/dir/file1.txt is saved if it is a pattern then /path/to/pattern-file1.txt is saved""" fname = file_path_pattern+'p_values.txt' np.savetxt(fname, self._pvalues) fname = file_path_pattern+'p_values.png' pl.figure() pl.imshow(self._pvalues, interpolation='nearest') pl.colorbar() pl.savefig(fname) fname = file_path_pattern+'values.txt' np.savetxt(fname, self._measure) fname = file_path_pattern+'values.png' pl.figure() pl.imshow(self._measure, interpolation='nearest', vmax=1, vmin=-1) pl.colorbar() pl.savefig(fname)
def test1_2d_esmf_native_tripolar_fraction(self): mype = MPI.COMM_WORLD.Get_rank() f = cdms2.open(cdat_info.get_sampledata_path() + \ '/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc') so = f('so')[0, 0, :, :] h = cdms2.open(cdat_info.get_sampledata_path() + \ '/so_Omon_HadGEM2-CC_historical_r1i1p1_185912-186911_2timesteps.nc') hadGEM2Model = h('so')[0, 0, ...] ny, nx = so.shape soBounds = so.getGrid().getBounds() srcLatCorner = numpy.zeros((ny + 1, nx + 1), numpy.float32) srcLatCorner[:ny, :nx] = soBounds[0][:, :, 0] srcLatCorner[:ny, nx] = soBounds[0][:ny, nx - 1, 1] srcLatCorner[ny, nx] = soBounds[0][ny - 1, nx - 1, 2] srcLatCorner[ny, :nx] = soBounds[0][ny - 1, :nx, 3] srcLonCorner = numpy.zeros((ny + 1, nx + 1), numpy.float32) srcLonCorner[:ny, :nx] = soBounds[1][:, :, 0] srcLonCorner[:ny, nx] = soBounds[1][:ny, nx - 1, 1] srcLonCorner[ny, nx] = soBounds[1][ny - 1, nx - 1, 2] srcLonCorner[ny, :nx] = soBounds[1][ny - 1, :nx, 3] srcCells = [so.getLatitude(), so.getLongitude()] srcNodes = [srcLatCorner, srcLonCorner] clt = cdms2.open(cdat_info.get_sampledata_path() + '/clt.nc')('clt')[0, :, :] cltBounds = clt.getGrid().getBounds() ny, nx = clt.shape # clt grid is rectilinear, transform to curvilinear CLGrid = clt.getGrid().toCurveGrid() #lats = CLGrid.getLatitude()[:].data lons = CLGrid.getLongitude()[:].data # Make the bounds go from -90, 90 with uniform spacing and the # Cell Centers go from -88.something to 88.something yb = numpy.linspace(-90, 90, ny + 1) interval = abs(yb[0] - yb[1]) y = numpy.linspace(-90 + interval / 2., 90 - interval / 2., ny) lats = numpy.outer(y, numpy.ones((nx), numpy.float32)) ny, nx = clt.shape #yb = numpy.zeros((ny+1,), numpy.float32) #yb[:ny] = cltBounds[0][:, 0] #yb[ny] = cltBounds[0][ny-1, 1] xb = numpy.zeros((nx + 1, ), numpy.float32) xb[:nx] = cltBounds[1][:, 0] xb[nx] = cltBounds[1][nx - 1, 1] # make curvilinear dstLatCorner = numpy.outer(yb, numpy.ones((nx + 1, ), numpy.float32)) dstLonCorner = numpy.outer(numpy.ones((ny + 1, ), numpy.float32), xb) dstCells = [lats, lons] dstNodes = [dstLatCorner, dstLonCorner] print 'running test2_2d_esmf_native_tripolar_fraction...' tic = time.time() # create grid srcMaxIndex = numpy.array(so.shape[::-1], dtype=numpy.int32) srcGrid = ESMP.ESMP_GridCreate1PeriDim( srcMaxIndex, coordSys=ESMP.ESMP_COORDSYS_SPH_DEG) ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER) ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER) srcDimsCenter = ESMP.ESMP_GridGetCoord(srcGrid, ESMP.ESMP_STAGGERLOC_CENTER) srcDimsCorner = ESMP.ESMP_GridGetCoord(srcGrid, ESMP.ESMP_STAGGERLOC_CORNER) srcXCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0, ESMP.ESMP_STAGGERLOC_CENTER) srcYCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1, ESMP.ESMP_STAGGERLOC_CENTER) srcXCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0, ESMP.ESMP_STAGGERLOC_CORNER) srcYCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1, ESMP.ESMP_STAGGERLOC_CORNER) dstMaxIndex = numpy.array(clt.shape[::-1], dtype=numpy.int32) dstGrid = ESMP.ESMP_GridCreate1PeriDim( dstMaxIndex, coordSys=ESMP.ESMP_COORDSYS_SPH_DEG) ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER) ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER) dstDimsCenter = ESMP.ESMP_GridGetCoord(dstGrid, ESMP.ESMP_STAGGERLOC_CENTER) dstDimsCorner = ESMP.ESMP_GridGetCoord(dstGrid, ESMP.ESMP_STAGGERLOC_CORNER) dstXCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0, ESMP.ESMP_STAGGERLOC_CENTER) dstYCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1, ESMP.ESMP_STAGGERLOC_CENTER) dstXCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0, ESMP.ESMP_STAGGERLOC_CORNER) dstYCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1, ESMP.ESMP_STAGGERLOC_CORNER) # mask ESMP.ESMP_GridAddItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK) srcMask = ESMP.ESMP_GridGetItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK) # create field srcFld = ESMP.ESMP_FieldCreateGrid( srcGrid, 'srcFld', typekind=ESMP.ESMP_TYPEKIND_R4, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER) srcFldPtr = ESMP.ESMP_FieldGetPtr(srcFld) dstFld = ESMP.ESMP_FieldCreateGrid( dstGrid, 'dstFld', typekind=ESMP.ESMP_TYPEKIND_R4, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER) dstFldPtr = ESMP.ESMP_FieldGetPtr(dstFld) # Create the field for the fractional areas srcFracFld = ESMP.ESMP_FieldCreateGrid( srcGrid, 'srcFrac', typekind=ESMP.ESMP_TYPEKIND_R4, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER) srcFracPtr = ESMP.ESMP_FieldGetPtr(srcFracFld) dstFracFld = ESMP.ESMP_FieldCreateGrid( dstGrid, 'dstFrac', typekind=ESMP.ESMP_TYPEKIND_R4, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER) dstFracPtr = ESMP.ESMP_FieldGetPtr(dstFracFld) # set coords, mask, and field values for src and dst srcNtotCenter = reduce(operator.mul, [srcDimsCenter[1][i] - srcDimsCenter[0][i] \ for i in range(2)]) srcNtotCorner = reduce(operator.mul, [srcDimsCorner[1][i] - srcDimsCorner[0][i] \ for i in range(2)]) srcJCenterBeg = srcDimsCenter[0][1] srcJCenterEnd = srcDimsCenter[1][1] srcJCornerBeg = srcDimsCorner[0][1] srcJCornerEnd = srcDimsCorner[1][1] srcICenterBeg = srcDimsCenter[0][0] srcICenterEnd = srcDimsCenter[1][0] srcICornerBeg = srcDimsCorner[0][0] srcICornerEnd = srcDimsCorner[1][0] srcXCenter[:] = numpy.reshape( srcCells[1][srcJCenterBeg:srcJCenterEnd, srcICenterBeg:srcICenterEnd], (srcNtotCenter, )) srcYCenter[:] = numpy.reshape( srcCells[0][srcJCenterBeg:srcJCenterEnd, srcICenterBeg:srcICenterEnd], (srcNtotCenter, )) srcXCorner[:] = numpy.reshape( srcNodes[1][srcJCornerBeg:srcJCornerEnd, srcICornerBeg:srcICornerEnd], (srcNtotCorner, )) srcYCorner[:] = numpy.reshape( srcNodes[0][srcJCornerBeg:srcJCornerEnd, srcICornerBeg:srcICornerEnd], (srcNtotCorner, )) srcFldPtr[:] = numpy.reshape( so[srcJCenterBeg:srcJCenterEnd, srcICenterBeg:srcICenterEnd], (srcNtotCenter, )) srcMask[:] = (srcFldPtr == so.missing_value) srcFracPtr[:] = -999 dstFracPtr[:] = -999 dstNtotCenter = reduce( operator.mul, [dstDimsCenter[1][i] - dstDimsCenter[0][i] for i in range(2)]) dstNtotCorner = reduce( operator.mul, [dstDimsCorner[1][i] - dstDimsCorner[0][i] for i in range(2)]) dstXCenter[:] = numpy.reshape( dstCells[1][dstDimsCenter[0][1]:dstDimsCenter[1][1], dstDimsCenter[0][0]:dstDimsCenter[1][0]], (dstNtotCenter)) dstXCenter[:] = numpy.reshape( dstCells[0][dstDimsCenter[0][1]:dstDimsCenter[1][1], dstDimsCenter[0][0]:dstDimsCenter[1][0]], (dstNtotCenter)) dstXCorner[:] = numpy.reshape( dstNodes[1][dstDimsCorner[0][1]:dstDimsCorner[1][1], dstDimsCorner[0][0]:dstDimsCorner[1][0]], (dstNtotCorner, )) dstYCorner[:] = numpy.reshape( dstNodes[0][dstDimsCorner[0][1]:dstDimsCorner[1][1], dstDimsCorner[0][0]:dstDimsCorner[1][0]], (dstNtotCorner, )) dstFldPtr[:] = 0 srcAreaFld = ESMP.ESMP_FieldCreateGrid(srcGrid, 'srcArea') dstAreaFld = ESMP.ESMP_FieldCreateGrid(dstGrid, 'dstArea') # regrid forward and backward maskVals = numpy.array([1], numpy.int32) # values defining mask regrid1 = ESMP.ESMP_FieldRegridStore( srcFld, dstFld, srcMaskValues=maskVals, dstMaskValues=None, regridmethod=ESMP.ESMP_REGRIDMETHOD_CONSERVE, unmappedaction=ESMP.ESMP_UNMAPPEDACTION_IGNORE, srcFracField=srcFracFld, dstFracField=dstFracFld) ESMP.ESMP_FieldRegrid(srcFld, dstFld, regrid1) srcAreas = ESMP.ESMP_FieldRegridGetArea(srcAreaFld) dstAreas = ESMP.ESMP_FieldRegridGetArea(dstAreaFld) srcAreaPtr = ESMP.ESMP_FieldGetPtr(srcAreaFld) dstAreaPtr = ESMP.ESMP_FieldGetPtr(dstAreaFld) if mype == 0: srcHasNan = numpy.any(numpy.isnan(srcFracPtr)) dstHasNan = numpy.any(numpy.isnan(dstFracPtr)) aa = numpy.isnan(srcFracPtr) bb = numpy.isnan(dstFracPtr) cc = srcFldPtr == 0 dd = dstFldPtr == 0 if PLOT: pl.figure(1) pl.subplot(2, 1, 1) pl.pcolor(numpy.reshape(aa, so.shape)) pl.colorbar() pl.title('source') pl.subplot(2, 1, 2) pl.pcolor(numpy.reshape(bb, clt.shape)) pl.colorbar() pl.title('destination') pl.suptitle("Red == location of nan's") print srcHasNan, dstHasNan # Do they have nans? self.assertFalse(srcHasNan, True) self.assertFalse(dstHasNan, True) jbeg, jend = dstDimsCenter[0][1], dstDimsCenter[1][1] ibeg, iend = dstDimsCenter[0][0], dstDimsCenter[1][0] soInterp = numpy.reshape(dstFldPtr, (jend - jbeg, iend - ibeg)) toc = time.time() # clean up ESMP.ESMP_FieldRegridRelease(regrid1) ESMP.ESMP_FieldDestroy(dstFld) ESMP.ESMP_GridDestroy(dstGrid) ESMP.ESMP_FieldDestroy(srcFld) ESMP.ESMP_GridDestroy(srcGrid)
plt.figure(1) #plt.subplot(121) x = np.linspace(-25.4, +25.4, A.shape[1], endpoint=True) y = np.linspace(0, 128, A.shape[0], endpoint=True) x_ds, y_ds = np.meshgrid(x, y) A = np.where(A > 0, A, 0.0001) A = np.log10(np.power(A, 2)) print y_ds.shape, x_ds.shape, A.shape #plt.pcolormesh(x_ds,y_ds, A, cmap=cm.Greys,vmin=-1,vmax=3) ax = plt.imshow(A, aspect='auto', cmap=cm.Greys, interpolation='nearest', vmin=-1, origin='lower') plt.colorbar() #plt.ylim(0, 128) #plt.xlim(-25.4,25.4) plt.ylabel(r"Lag $\tau$ ") plt.title(r"$|\tilde{E}(\tau,f_D)|$") plt.xlabel(r"Doppler Frequency $f_D$ ") #plt.subplot(122) fig.add_subplot(gs[:2, 2:4]) bina = 1 binb = 1 a_num = cj.shape[0] b_num = cj.shape[1] a_vv = np.copy(cj.reshape(a_num // bina, bina, b_num // binb, binb)) cj = np.mean(np.mean(a_vv, axis=3), axis=1) cj = np.abs(cj) cj = np.where(cj > 0, cj, 0.0001)
def exampleNetworks(): names = [ u'Yoachim, P', u'Bellm, E', u'Williams, B', u'Williams, B', u'Capelo, P' ] # add some caching so it only querries once. if not hasattr(exampleNetworks, 'results'): exampleNetworks.results = [None for name in names] exampleNetworks.graphs = [None for name in names] years = [2007, 2011, 2002, 2010, 2012] texts = ['(a)', '(b)', '(c)', '(d)', '(e)'] count = 1 figs = [] filenames = [] for name, year, txt in zip(names, years, texts): fig, ax = plt.subplots() figDummy, axDummy = plt.subplots() phdA = list( ads.SearchQuery(q=u'bibstem:*PhDT', author=name, year=year, database='astronomy'))[-1] if exampleNetworks.results[count - 1] is None: result, graph = phdArticle2row(phdA, checkUSA=False, verbose=True, returnNetwork=True) exampleNetworks.results[count - 1] = result exampleNetworks.graphs[count - 1] = graph else: result = exampleNetworks.results[count - 1] graph = exampleNetworks.graphs[count - 1] years = [] for node in graph.nodes(): years.append(float(node[0:4])) years = np.array(years) # Make the graph repeatable pos = {} for i, node in enumerate(graph.nodes()): pos[node] = (years[i], i**2) layout = nx.spring_layout(graph, pos=pos) nx.draw_networkx(graph, pos=layout, ax=ax, node_size=100, node_color=years, alpha=0.5, with_labels=False) #nx.draw_spring(graph, ax=ax, node_size=100, # node_color=years, alpha=0.5, with_labels=False) mappableDummy = axDummy.scatter(years, years, c=years) cbar = plt.colorbar(mappableDummy, ax=ax, format='%i') cbar.set_label('Year') ax.text(.1, .8, txt, fontsize=24, transform=ax.transAxes) ax.set_axis_off() figs.append(fig) filenames.append('example_network_%i' % count) count += 1 print result return figs, filenames
def autocorrect(out, ant_str='ant1-13', brange=[0, 300]): nt = len(out['time']) nf = len(out['fghz']) pfac1 = (out['p'][:, :, :, :-1] - out['p'][:, :, :, 1:]) / out['p'][:, :, :, :-1] trange = Time(out['time'][[0, -1]], format='jd') src_lev = gc.get_fem_level(trange) # Read FEM levels from SQL # Match times with data tidx = nearest_val_idx(out['time'], src_lev['times'].jd) # Find attenuation changes for ant in range(13): for pol in range(2): if pol == 0: lev = src_lev['hlev'][ant, tidx] else: lev = src_lev['vlev'][ant, tidx] jidx, = np.where(abs(lev[:-1] - lev[1:]) == 1) for freq in range(nf): idx, = np.where( np.logical_and( abs(pfac1[ant, pol, freq]) > 0.05, abs(pfac1[ant, pol, freq]) < 0.95)) for i in range(len(idx - 1)): if idx[i] in jidx or idx[i] in jidx - 1: out['p'][ant, pol, freq, idx[i] + 1:] /= (1 - pfac1[ant, pol, freq, idx[i]]) # Time of total power calibration is 20 UT on the date given tptime = Time(np.floor(trange[0].mjd) + 20. / 24., format='mjd') calfac = pc.get_calfac(tptime) tpcalfac = calfac['tpcalfac'] tpoffsun = calfac['tpoffsun'] hlev = src_lev['hlev'][:13, 0] vlev = src_lev['vlev'][:13, 0] attn_dict = ac.read_attncal(trange[0])[0] # Read GCAL attn from SQL attn = np.zeros((13, 2, nf)) for i in range(13): attn[i, 0] = attn_dict['attn'][hlev[i], 0, 0] attn[i, 1] = attn_dict['attn'][vlev[i], 0, 1] print 'Ant', i + 1, attn[i, 0, 20], attn[i, 1, 20] attnfac = 10**(attn / 10.) for i in range(13): print attnfac[i, 0, 20], attnfac[i, 1, 20] for i in range(nt): out['p'][:13, :, :, i] = (out['p'][:13, :, :, i] * attnfac - tpoffsun) * tpcalfac antlist = ant_str2list(ant_str) bg = np.zeros_like(out['p']) # Subtract background for each antenna/polarization for ant in antlist: for pol in range(2): bg[ant, pol] = np.median(out['p'][ant, pol, :, brange[0]:brange[1]], 1).repeat(nt).reshape(nf, nt) #out['p'][ant,pol] -= bg # Form median over antennas/pols med = np.mean(np.median((out['p'] - bg)[antlist], 0), 0) # Do background subtraction once more for good measure bgd = np.median(med[:, brange[0]:brange[1]], 1).repeat(nt).reshape(nf, nt) med -= bgd pdata = np.log10(med) f, ax = plt.subplots(1, 1) vmax = np.median(np.nanmax(pdata, 1)) im = ax.pcolormesh(Time(out['time'], format='jd').plot_date, out['fghz'], pdata, vmin=1, vmax=vmax) ax.axvspan(Time(out['time'][brange[0]], format='jd').plot_date, Time(out['time'][brange[1]], format='jd').plot_date, color='w', alpha=0.3) cbar = plt.colorbar(im, ax=ax) cbar.set_label('Log Flux Density [sfu]') ax.xaxis_date() ax.xaxis.set_major_formatter(DateFormatter("%H:%M")) ax.set_ylim(out['fghz'][0], out['fghz'][-1]) ax.set_xlabel('Time [UT]') ax.set_ylabel('Frequency [GHz]') return {'caldata': out, 'med_sub': med, 'bgd': bg}
def Uimg(self, x, t, exactu, predu, label='test', label2='test', savename='u', isCycle=False): X, T = np.meshgrid(x, t) #[100,256] X_star = np.hstack( (X.flatten()[:, None], T.flatten()[:, None])) # [25600,2] # exactu [25,100] us = [exactu.T, predu.T] #pdb.set_trace() # u of exact nu (row0) -> pred nu (row1) fig, axes = plt.subplots(nrows=2) for row, u in enumerate(us): # u[100,25] u_star = u.flatten()[:, None] # [25600,1] # [100,100] U_star = griddata(X_star, u_star.flatten(), (X, T), method='cubic') #pdb.set_trace() img = axes[row].imshow(U_star.T, interpolation='nearest', cmap='gray', origin='lower') if isCycle: if row == 0: #pdb.set_trace() titlelabel = ['exact nu=', 'lloss'] axes[row].set_title( '%s %.3f %s %.10f' % (titlelabel[0], np.float(label.split('_')[row]), titlelabel[1], np.float(label2.split('_')[2]))) elif row == 1: titlelabel = ['predict nu=', 'closs', 'grad'] #axes[row].set_title('%s %.3f %s %.2f %s %.12f' % (titlelabel[0], np.float(label.split('_')[row][1:-1]), titlelabel[1], np.float(label2.split('_')[0][1:-1]), titlelabel[2], np.float(label2.split('_')[1]))) #pdb.set_trace() axes[row].set_title( '%s %.5f %s %.10f' % (titlelabel[0], np.float(label.split('_')[row][1:-1]), titlelabel[1], np.float(label2.split('_')[0]))) else: if row == 0: titlelabel = 'exact nu=' elif row == 1: titlelabel = 'predict nu=' #pdb.set_trace() axes[row].set_title( '%s %5f' % (titlelabel, np.float(label.split('_')[row][1:-1]))) divider1 = make_axes_locatable(axes[row]) cax1 = divider1.append_axes("right", size="2%", pad=0.1) plt.colorbar(img, cax=cax1) axes[row].set_xlabel('t', fontsize=10) axes[row].set_ylabel('u(t,x)', fontsize=10) plt.tight_layout() fpath = os.path.join('figure', f'burgers_{savename}_{self.dataMode}') isdir = os.path.exists(fpath) if not isdir: os.makedirs(fpath) plt.savefig(os.path.join(fpath, f'{label}.png')) plt.close()
print('type(ions) is ', type(ions)) ions = np.array(ions, dtype=int) # change list to int array. print('type(ions) is ', type(ions)) ''' for atom in ions: folder = str(atom) print(folder) ''' #==================================================================================================== # plot the chosen ions type #==================================================================================================== data = np.loadtxt('test.dat') #print(data) scatters = plt.scatter(data[:, 2], data[:, 3], c=data[:, 1], cmap='coolwarm') cb = plt.colorbar(scatters, pad=0.01) plt.savefig('point_distribution.pdf') plt.show() #==================================================================================================== filename = 'build_noclimb.sh' print("=============================================================") flag = input("Do you want to clean earlier results (y or n) \n \ This will delete all the folders in current folder. : ") if (flag == 'y'): for folder in os.listdir(): if (os.path.isdir(folder)): os.system('rm -r ' + folder) #os.rmdir(folder)
C1 = sp.spatial.distance.cdist(xs, xs) C2 = sp.spatial.distance.cdist(xt, xt) C1 /= C1.max() C2 /= C2.max() pl.figure() pl.subplot(121) pl.imshow(C1) pl.subplot(122) pl.imshow(C2) pl.show() p = ot.unif(n_samples) q = ot.unif(n_samples) gw0, log0 = ot.gromov.gromov_wasserstein(C1, C2, p, q, 'square_loss', verbose=True, log=True) print('Gromov-Wasserstein distances: ' + str(log0['gw_dist'])) pl.figure(1, (10, 5)) pl.imshow(gw0, cmap='jet') pl.title('Gromov Wasserstein') pl.colorbar() pl.show()
def plot_results(filename, ccdnr=1, pngfile=None, panels='residual'): # # # if (not os.path.isfile(filename)): raise FileNotFoundError # with fits.open(filename) as hdu: resid = hdu['RESIDUALS'].data[ccdnr - 1, :, :] errors = hdu['ERRORS'].data[ccdnr - 1, :, :] chi2r = hdu['CHI2_R'].data[ccdnr - 1, :, :] rev_start = hdu[0].header['REV0'] rev_end = hdu[0].header['REV1'] # # calculate sigma_clipped statistics # xstat = stats.sigma_clipped_stats(resid, sigma=3, maxiters=3) # rawy_array = np.arange(20, 200, 20) if (panels == 'all'): fig, ax = plt.subplots(nrows=3, ncols=1, figsize=(10, 10), sharex=True) im = ax[0].imshow(resid, vmin=-100, vmax=100.0, origin='lower', cmap=plt.get_cmap('bwr')) div = make_axes_locatable(ax[0]) cax = div.append_axes("right", size="5%", pad=0.1) cbar = plt.colorbar(im, cax=cax) cbar.set_label('E - 8040 (eV)') ax[0].set_title(f'CCD: {ccdnr}, revs in [{rev_start},{rev_end}]') ax[0].set_xlabel( fr'mean={xstat[0]:.1f} eV, st.dev.={xstat[2]:.1f} eV (3-$\sigma$ clipped)' ) #ax[0].set_xticks(rawy_array) # im = ax[1].imshow(errors, vmin=0.0, vmax=20.0, origin='lower', cmap=plt.get_cmap('bwr')) div = make_axes_locatable(ax[1]) cax = div.append_axes("right", size="5%", pad=0.1) cbar = plt.colorbar(im, cax=cax) cbar.set_label('Error (eV)') #ax[1].set_title(f'CCD: {ccd}') #ax[1].set_xticks(rawy_array) # im = ax[2].imshow(chi2r, vmin=1.0, vmax=2.0, origin='lower', cmap=plt.get_cmap('bwr')) div = make_axes_locatable(ax[2]) cax = div.append_axes("right", size="5%", pad=0.1) cbar = plt.colorbar(im, cax=cax) cbar.set_label('Chi2_r') #ax[2].set_title(f'CCD: {ccd}') ax[2].set_xticks(rawy_array) # if (pngfile is not None): plt.savefig(pngfile, dpi=100) plt.show() else: fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6), sharex=True) im = ax.imshow(resid, vmin=-100, vmax=100.0, origin='lower', cmap=plt.get_cmap('bwr')) div = make_axes_locatable(ax) cax = div.append_axes("right", size="5%", pad=0.1) cbar = plt.colorbar(im, cax=cax) cbar.set_label('E - 8040 (eV)') ax.set_xticks(rawy_array) ax.set_xlabel('RAWY') ax.set_ylabel('RAWX') ax.set_title( f'CCD: {ccdnr}, revs in [{rev_start},{rev_end}]\n' + fr'mean={xstat[0]:.1f} eV, st.dev.={xstat[2]:.1f} eV (3-$\sigma$ clipped)' ) #plt.title(fr'mean={xstat[0]:.1f} eV, st.dev.={xstat[2]:.1f} eV (3-$\sigma$ clipped)',ha='right',fontsize=16) if (pngfile is not None): plt.savefig(pngfile, dpi=100) plt.show() return
def test_2d(self): mype = 0 if HAS_MPI: mype = MPI.COMM_WORLD.Get_rank() f = cdms2.open( cdat_info.get_sampledata_path() + '/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc') so = f['so'] # [0, 0, :, :] clt = cdms2.open(cdat_info.get_sampledata_path() + '/clt.nc')('clt')[0, :, :] # ESMF interface, assume so and clt are cell centered srcGrid = regrid2.esmf.EsmfStructGrid(so[0, 0, ...].shape, coordSys=ESMF.CoordSys.SPH_DEG, periodicity=0) dstGrid = regrid2.esmf.EsmfStructGrid(clt.shape, coordSys=ESMF.CoordSys.SPH_DEG, periodicity=0) grid = [so.getGrid().getLatitude(), so.getGrid().getLongitude()] srcGrid.setCoords(grid, staggerloc=ESMF.StaggerLoc.CENTER, globalIndexing=True) # convert to curvilinear ny, nx = clt.shape y = clt.getGrid().getLatitude() x = clt.getGrid().getLongitude() yy = numpy.outer(y, numpy.ones((nx, ), numpy.float32)) xx = numpy.outer(numpy.ones((ny, ), numpy.float32), x) dstGrid.setCoords([yy, xx], staggerloc=ESMF.StaggerLoc.CENTER, globalIndexing=True) # mask = numpy.zeros(so[0, 0, ...].shape, numpy.int32) # mask[:] = (so[0, 0, ...] == so.missing_value) mask = so[0, 0, :].mask srcGrid.setMask(mask) srcFld = regrid2.esmf.EsmfStructField( srcGrid, 'srcFld', datatype=so[:].dtype, staggerloc=ESMF.StaggerLoc.CENTER) srcSlab = srcGrid.getLocalSlab(ESMF.StaggerLoc.CENTER) dstSlab = dstGrid.getLocalSlab(ESMF.StaggerLoc.CENTER) srcFld.setLocalData(numpy.array(so[0, 0, srcSlab[0], srcSlab[1]]), staggerloc=ESMF.StaggerLoc.CENTER) dstFld = regrid2.esmf.EsmfStructField( dstGrid, 'dstFld', datatype=so.dtype, staggerloc=ESMF.StaggerLoc.CENTER) dstData = numpy.ones(clt.shape, numpy.float32)[dstSlab[0], dstSlab[1]] dstFld.setLocalData(so.missing_value * dstData, staggerloc=ESMF.StaggerLoc.CENTER) rgrd1 = regrid2.esmf.EsmfRegrid( srcFld, dstFld, srcFrac=None, dstFrac=None, srcMaskValues=numpy.array([1], numpy.int32), dstMaskValues=numpy.array([1], numpy.int32), regridMethod=ESMF.RegridMethod.BILINEAR, unMappedAction=ESMF.UnmappedAction.IGNORE) # now interpolate rgrd1(srcFld, dstFld) # get the data on this proc soInterpEsmfInterface = dstFld.getData(rootPe=None) # gather the data on proc 0 soInterpEsmfInterfaceRoot = dstFld.getData(rootPe=0) print(('[%d] esmfInterface chksum = %f' % (mype, soInterpEsmfInterface.sum()))) if mype == 0: print(('ROOT esmfInterface chksum = %f' % soInterpEsmfInterfaceRoot.sum())) # Native ESMP srcMaxIndex = numpy.array(so[0, 0, ...].shape[::-1], dtype=numpy.int32) # srcMaxIndex = numpy.array(so[0, 0, ...].shape, dtype=numpy.int32) srcGrid = ESMF.Grid(srcMaxIndex, coord_sys=ESMF.CoordSys.SPH_DEG, staggerloc=[ESMF.StaggerLoc.CENTER]) # srcGrid = ESMP.ESMP_GridCreateNoPeriDim(srcMaxIndex, # coordSys = ESMP.ESMP_COORDSYS_SPH_DEG) # ESMP.ESMP_GridAddCoord(srcGrid, # staggerloc = ESMF.StaggerLoc.CENTER) srcDimsCenter = [ srcGrid.lower_bounds[ESMF.StaggerLoc.CENTER], srcGrid.upper_bounds[ESMF.StaggerLoc.CENTER] ] # srcDimsCenter = ESMP.ESMP_GridGetCoord(srcGrid, # ESMF.StaggerLoc.CENTER) srcXCenter = srcGrid.get_coords(0, staggerloc=ESMF.StaggerLoc.CENTER) srcYCenter = srcGrid.get_coords(1, staggerloc=ESMF.StaggerLoc.CENTER) # srcXCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0, # ESMF.StaggerLoc.CENTER) # srcYCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1, # ESMF.StaggerLoc.CENTER) dstMaxIndex = numpy.array(clt.shape[::-1], dtype=numpy.int32) # dstMaxIndex = numpy.array(clt.shape, dtype=numpy.int32) dstGrid = ESMF.Grid(dstMaxIndex, coord_sys=ESMF.CoordSys.SPH_DEG, staggerloc=[ESMF.StaggerLoc.CENTER]) # dstGrid = ESMP.ESMP_GridCreateNoPeriDim(dstMaxIndex, # coordSys = ESMP.ESMP_COORDSYS_SPH_DEG) # ESMP.ESMP_GridAddCoord(dstGrid, # staggerloc = ESMF.StaggerLoc.CENTER) dstDimsCenter = [ dstGrid.lower_bounds[ESMF.StaggerLoc.CENTER], dstGrid.upper_bounds[ESMF.StaggerLoc.CENTER] ] # dstDimsCenter = ESMP.ESMP_GridGetCoord(dstGrid, # ESMF.StaggerLoc.CENTER) dstXCenter = dstGrid.get_coords(0, staggerloc=ESMF.StaggerLoc.CENTER) dstYCenter = dstGrid.get_coords(1, staggerloc=ESMF.StaggerLoc.CENTER) # dstXCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0, # ESMF.StaggerLoc.CENTER) # dstYCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1, # ESMF.StaggerLoc.CENTER) # mask srcGrid.add_item(item=ESMF.GridItem.MASK) # ESMP.ESMP_GridAddItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK) srcMask = srcGrid.get_item(item=ESMF.GridItem.MASK) # srcMask = ESMP.ESMP_GridGetItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK) # create field srcFld = ESMF.Field(srcGrid, name='srcFld', typekind=ESMF.TypeKind.R4, staggerloc=ESMF.StaggerLoc.CENTER) srcFldPtr = srcFld.data dstFld = ESMF.Field(dstGrid, name='dstFld', typekind=ESMF.TypeKind.R4, staggerloc=ESMF.StaggerLoc.CENTER) dstFldPtr = dstFld.data # set coords, mask, and field values for src and dst srcNtot = reduce( operator.mul, [srcDimsCenter[1][i] - srcDimsCenter[0][i] for i in range(2)]) srcXCenter[:] = so.getGrid().getLongitude()[:].T srcYCenter[:] = so.getGrid().getLatitude()[:].T srcFldPtr[:] = so[0, 0, :].T srcMask[:] = (srcFldPtr == so.missing_value) # clt grid is rectilinear, transform to curvilinear lons = clt.getGrid().getLongitude() lats = clt.getGrid().getLatitude() ny, nx = dstDimsCenter[1][1] - \ dstDimsCenter[0][1], dstDimsCenter[1][0] - dstDimsCenter[0][0] localLons = lons[dstDimsCenter[0][0]:dstDimsCenter[1][0]] localLats = lats[dstDimsCenter[0][1]:dstDimsCenter[1][1]] xx = numpy.outer(localLons, numpy.ones((ny, ), dtype=numpy.float32)) yy = numpy.outer(numpy.ones((nx, ), dtype=numpy.float32), localLats) dstXCenter[:] = xx dstYCenter[:] = yy dstFldPtr[:] = so.missing_value # regrid forward and backward maskVals = numpy.array([1], numpy.int32) # values defining mask regrid1 = ESMF.Regrid(srcFld, dstFld, src_mask_values=maskVals, dst_mask_values=None, regrid_method=ESMF.RegridMethod.BILINEAR, unmapped_action=ESMF.UnmappedAction.IGNORE, src_frac_field=None, dst_frac_field=None) regrid1(srcFld, dstFld, zero_region=ESMF.Region.SELECT) jbeg, jend = dstDimsCenter[0][0], dstDimsCenter[1][0] ibeg, iend = dstDimsCenter[0][1], dstDimsCenter[1][1] soInterpESMP = numpy.ma.masked_where((dstFldPtr == so.missing_value), dstFldPtr).T soInterpEsmfInterface = numpy.ma.masked_where( soInterpEsmfInterface == so.missing_value, soInterpEsmfInterface) soInterpEsmfInterfaceRoot = numpy.ma.masked_where( soInterpEsmfInterfaceRoot == so.missing_value, soInterpEsmfInterfaceRoot) # check local diffs ntot = reduce(operator.mul, soInterpESMP.shape) avgdiff = numpy.sum(soInterpEsmfInterface - soInterpESMP) / float(ntot) self.assertLess(abs(avgdiff), 1.e-7) # check gather chksumESMP = numpy.sum(soInterpESMP) chksumEsmfInterface = numpy.sum(soInterpEsmfInterface) if HAS_MPI: chksumsESMP = MPI.COMM_WORLD.gather(chksumESMP, root=0) else: chksumsESMP = chksumESMP print(('[%d] ESMP chksum = %f' % (mype, chksumESMP))) if mype == 0: print(('ROOT ESMP chksum = %f' % numpy.sum(chksumsESMP))) if mype == 0: chksumESMPRoot = numpy.sum(chksumsESMP) chksumESMFInterfaceRoot = numpy.sum(soInterpEsmfInterfaceRoot) self.assertLess(abs(chksumESMFInterfaceRoot - chksumESMPRoot), 1.e-5 * chksumESMPRoot) if PLOT: pylab.subplot(2, 2, 1) pylab.pcolor(so, vmin=20.0, vmax=40.0) pylab.colorbar() pylab.title('so') pylab.subplot(2, 2, 2) pylab.pcolor(soInterpEsmfInterface - soInterpESMP, vmin=-0.5, vmax=0.5) pylab.colorbar() pylab.title('[%d] EsmfInterface - ESMP' % mype) pylab.subplot(2, 2, 3) pylab.pcolor(soInterpEsmfInterface, vmin=20.0, vmax=40.0) pylab.colorbar() pylab.title('[%d] ESMFInterface' % mype) pylab.subplot(2, 2, 4) pylab.pcolor(soInterpESMP, vmin=20, vmax=40) pylab.colorbar() pylab.title('[%d] ESMP' % mype)
edgecolor_constructor = [] linewidth_constructor = [] counter = 0 for i in range(8): for j in range(8): if i == 7-j or i == 8-j: edgecolor_constructor.append('w') linewidth_constructor.append(2) else: edgecolor_constructor.append('w') linewidth_constructor.append(.5) pt.figure() pt.pcolor( fitness_table[::-1], cmap = 'RdBu', vmin=-8,vmax=8,edgecolors='w', linewidth=.5) pt.colorbar(label='Median fitness (%)') ax = pt.gca() ax.set_xticks(numpy.arange(.5,8.7,1)) ax.set_yticks(numpy.arange(.5,8.7,1)) ax.set_xticklabels(evolution_env_labels,fontsize=8) ax.set_yticklabels(measurement_env_labels[::-1],fontsize=8) ax.set_xlim(0,8) ax.set_ylim(0,8) ax.tick_params(axis=u'both', which=u'both',length=0) ax.set_xlabel('Measurement environment',fontsize=14) ax.set_ylabel('Evolution environment',fontsize=14) pt.plot([0,8],[8,0],'--',color='Gray',linewidth=.5) for i in range(8): for j in range(8): if fitness_table[i,7-j] < 0 and fitness_table[i,7-j] > -.1: ###This will get printed as -0.0, so print 0.0 instead ax.text(7-j+.5,7-i+.5,abs(numpy.round(fitness_table[i,7-j],1)),color='Gray',fontsize=7,horizontalalignment='center',verticalalignment='center')
def calc_results(start_rev, ccdnr=1, mode='FF', pngfile=None, plot_it=True, stacks_dir=os.getcwd()): # # compare the CTI distribution of copper (8 keV) before and after the correction # step = 500 file0 = f'{stacks_dir}/{mode}_stacked_{start_rev:04}_{start_rev+step-1:04}_results.fits.gz' file1 = f'{stacks_dir}/{mode}_stacked_{start_rev:04}_{start_rev+step-1:04}_results_corr.fits.gz' if (not (os.path.isfile(file0) and os.path.isfile(file1))): raise FileNotFoundError # with fits.open(file0) as hdu0, fits.open(file1) as hdu1: resid0 = hdu0['RESIDUALS'].data[ccdnr - 1, :, :] resid1 = hdu1['RESIDUALS'].data[ccdnr - 1, :, :] # # calculate sigma_clipped statistics # xstat0 = stats.sigma_clipped_stats(resid0, sigma=3, maxiters=3) xstat1 = stats.sigma_clipped_stats(resid1, sigma=3, maxiters=3) # if (plot_it): rawy_array = np.arange(20, 200, 20) # fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(10, 10), sharex=True) # im = ax[0].imshow(resid0, vmin=-100, vmax=100.0, origin='lower', cmap=plt.get_cmap('bwr')) div = make_axes_locatable(ax[0]) cax = div.append_axes("right", size="5%", pad=0.1) cbar = plt.colorbar(im, cax=cax) cbar.set_label('E - 8040 (eV)') #ax.set_xticks(rawy_array) ax[0].set_xlabel('RAWY') #ax.set_ylabel('RAWX') ax[0].set_title( f'{mode}, CCD: {ccdnr}, revs in [{start_rev},{start_rev+step-1}]\n mean={xstat0[0]:.1f} eV, st.dev.={xstat0[2]:.1f} eV (3-$\sigma$ clipped)' ) #plt.title(fr'mean={xstat[0]:.1f} eV, st.dev.={xstat[2]:.1f} eV (3-$\sigma$ clipped)',ha='right',fontsize=16) im = ax[1].imshow(resid1, vmin=-100, vmax=100.0, origin='lower', cmap=plt.get_cmap('bwr')) div = make_axes_locatable(ax[1]) cax = div.append_axes("right", size="5%", pad=0.1) cbar = plt.colorbar(im, cax=cax) cbar.set_label('E - 8040 (eV)') #ax.set_xticks(rawy_array) ax[1].set_xlabel('RAWY') ax[1].set_ylabel('RAWX') ax[1].set_title( f'Corrected\n mean={xstat1[0]:.1f} eV, st.dev.={xstat1[2]:.1f} eV (3-$\sigma$ clipped)' ) if (pngfile is not None): plt.savefig(pngfile, dpi=100) plt.show() #time.sleep(10) plt.close() else: plt.show() return (xstat0, xstat1)
target_pix = wcs.wcs_sky2pix([(np.array([ra,dec], np.float_))], 1)[0] except: print "ERROR when converting sky to wcs. Is astrometry in place? Default coordinates assigned." target_pix = [+nx/2., ny/2.] print target_pix else: target_pix = [+nx/2., ny/2.] img = img - np.nanmin(img) av = np.median(img.flatten()) mi, ma = zscale.zscale(img) im = plt.imshow(plt.log10(img), aspect="equal", extent=(0, ny, 0, nx), \ origin="lower", cmap=matplotlib.cm.gray_r, interpolation="none", vmin=np.log10(av), vmax=np.log10(3*av)) #, interpolation="lanczos") plt.scatter(target_pix[0], target_pix[1], marker="x", s=10, c="red") plt.colorbar(im) filename = os.path.basename(f) plt.savefig(os.path.join(plot_dir, filename.replace("."+filename.split(".")[-1], "_{:}.png".format(i))), dpi=200) plt.clf() def move_to_discarded(mydir, myfilter, ra, dec): import shutil for f in glob.glob(os.path.join(mydir, myfilter)): frames_with_target = get_frames_with_target(f, ra, dec) if len(frames_with_target) == 0: discarddir = os.path.join(mydir, "discarded") if (not os.path.isdir(discarddir)): print "Creating directory for discarded files (with no target)" os.makedirs(discarddir) print "Moving file ",f," to discarded directory",discarddir
def false_hillshade(dH, title, pp=None, clim=(-20, 20)): """ Create a map figure showing the differences in black and white... :param dh: GeoImg object of elevation differences :param title: Title for plot :type geoimg: pybob.GeoImg :type title: str :returns fig: either prints to a pdf, or returns a figure """ niceext = np.array([dH.xmin, dH.xmax, dH.ymin, dH.ymax]) / 1000. dHtemp = np.ma.masked_invalid(dH.img) mykeep = np.ma.less(np.ma.abs(dHtemp), np.ma.std(dHtemp) * 3) # mykeep = np.logical_and.reduce((np.isfinite(dH.img), (np.abs(dH.img) < np.nanstd(dH.img) * 3))) dH_vec = dHtemp[mykeep] if pp is not None: fig = plt.figure(figsize=(7, 5), dpi=300) else: fig = plt.figure(figsize=(7, 5)) ax = plt.gca() im1 = ax.imshow(dH.img, extent=niceext, origin='upper') ymin = np.ma.mean(dH_vec) - 2 * np.ma.std(dH_vec) ymax = np.ma.mean(dH_vec) + 2 * np.ma.std(dH_vec) im1.set_clim(ymin, ymax) im1.set_cmap('Greys') # if np.sum(np.isfinite(dH_vec))<10: # print("Error for statistics in false_hillshade") # else: plt.title(title, fontsize=14) numwid = max([ len('{:.1f} m'.format(np.ma.mean(dH_vec))), len('{:.1f} m'.format(np.ma.median(dH_vec))), len('{:.1f} m'.format(np.ma.std(dH_vec))) ]) plt.annotate('MEAN:'.ljust(8) + ('{:.1f} m'.format(np.ma.mean(dH_vec))).rjust(numwid), xy=(0.65, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold', color='red', family='monospace') plt.annotate('MEDIAN:'.ljust(8) + ('{:.1f} m'.format(np.ma.median(dH_vec))).rjust(numwid), xy=(0.65, 0.90), xycoords='axes fraction', fontsize=12, fontweight='bold', color='red', family='monospace') plt.annotate('STD:'.ljust(8) + ('{:.1f} m'.format(np.ma.std(dH_vec))).rjust(numwid), xy=(0.65, 0.85), xycoords='axes fraction', fontsize=12, fontweight='bold', color='red', family='monospace') divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="5%", pad=0.05) plt.colorbar(im1, cax=cax) # plt.colorbar(im1) plt.tight_layout() gc.collect() if pp is not None: pp.savefig(fig, dpi=300) return else: return fig
'''########## SAVE SPREADING OF INFLUENCE GRAPH ON DISK ##########''' for year, top_results_year in top_results.items(): year_path = constants.TASK_1_PATH + str(year) + '/' create_clean_folders([year_path]) graph, starting_node, colors, labels = graph_to_save_year[year] pos = nx.spring_layout(graph, k=0.9, iterations=100) # positions for all nodes) graph: nx.Graph print(starting_node) ec = nx.draw_networkx_edges(graph.to_undirected(), pos, alpha=0.2) nc = nx.draw_networkx_nodes(graph, pos, nodelist=graph.nodes, node_color=colors, with_labels=True, node_size=100, cmap=cmap, vmin=vmin, vmax=vmax) lc = nx.draw_networkx_labels(graph, pos, labels, font_size=5) cb = plt.colorbar(nc) cb.set_label('Spreading of influence iteration (-1 if not influenced)') plt.axis('off') plt.savefig(year_path + str(starting_node), dpi=500) plt.close() influenced_path = year_path + 'spreading of influence/' create_clean_folders([influenced_path]) for el in top_results_year: topic = el[0] score = el[1] topic_path = influenced_path + str(score) + '_' + topic + '/' create_clean_folders([topic_path]) infl_nodes = influenced_nodes[year][str(year) + '_' + topic] f = open(topic_path + 'influenced_nodes.txt', "a") f.write(str(infl_nodes)) f.close()
qpi.compute_bg( which_data=["amplitude", "phase"], fit_offset="fit", fit_profile="tilt", border_px=5, ) # plot the properties of `qpi` fig = plt.figure(figsize=(8, 10)) matplotlib.rcParams["image.interpolation"] = "bicubic" holkw = {"cmap": "gray", "vmin": 0, "vmax": 200} ax1 = plt.subplot(321, title="cell hologram") map1 = ax1.imshow(edata["data"], **holkw) plt.colorbar(map1, ax=ax1, fraction=.046, pad=0.04) ax2 = plt.subplot(322, title="bg hologram") map2 = ax2.imshow(edata["bg_data"], **holkw) plt.colorbar(map2, ax=ax2, fraction=.046, pad=0.04) ax3 = plt.subplot(323, title="input phase [rad]") map3 = ax3.imshow(pha0) plt.colorbar(map3, ax=ax3, fraction=.046, pad=0.04) ax4 = plt.subplot(324, title="input amplitude") map4 = ax4.imshow(amp0, cmap="gray") plt.colorbar(map4, ax=ax4, fraction=.046, pad=0.04) ax5 = plt.subplot(325, title="corrected phase [rad]") map5 = ax5.imshow(qpi.pha)
#plt.scatter(x,y,c=density, vmin=-0.03, vmax=0.03, cmap='coolwarm') # hot, cool, coolwarm, gnuplot, gnuplot2, bwr, Reds scatters = plt.scatter( x / bmag, y / alat, c=density * 8.5, vmin=-0.015, vmax=0.015, cmap='coolwarm') # hot, cool, coolwarm, gnuplot, gnuplot2, bwr, Reds scatters = plt.scatter( x / bmag, (y + 82.5) / alat, c=density * 8.5, vmin=-0.015, vmax=0.015, cmap='coolwarm') # hot, cool, coolwarm, gnuplot, gnuplot2, bwr, Reds cb = plt.colorbar( scatters, pad=0.01) # pad controls the distance between bar and picture cb.set_label(label="Charge density (e/S)", size=45) cb.ax.tick_params(labelsize=35, direction='in') ''' cb.set_ticks(np.linspace(-0.015,0.015,7,endpoint=True)) #cbarlevels = ('-0.02', '-0.01', '-0.05', '0', '0.05', '0.01', '0.02') cbarlevels = ('-0.015', '-0.01', '-0.005','0', '0.005','0.01', '0.015') cb.set_ticklabels(cbarlevels) plt.clim(-0.015, 0.015) # lim of colorbar ''' # plot dislocation position with black line plt.plot(dipole[::2, 0] / bmag - 0.7, dipole[::2, 1] / alat, linewidth='5.0',
def showme(mesh, ifile, variable='temp', depth=0, box=[-180, 180, -90, 90], res=[360, 180], influence=80000, timestep=0, levels=None, quiet=None, ofile=None, mapproj='rob', abg=(50, 15, -90), clim=None, cmap=None, interp='nn', ptype='cf', k=5): if cmap: if cmap in cmo.cmapnames: colormap = cmo.cmap_d[cmap] elif cmap in plt.cm.datad: colormap = plt.get_cmap(cmap) else: raise ValueError( 'Get unrecognised name for the colormap `{}`. Colormaps should be from standard matplotlib set of from cmocean package.' .format(cmap)) else: if clim: colormap = cmo.cmap_d['balance'] else: colormap = plt.get_cmap('Spectral_r') sstep = timestep radius_of_influence = influence left, right, down, up = box lonNumber, latNumber = res print(ifile) flf = Dataset(ifile) lonreg = np.linspace(left, right, lonNumber) latreg = np.linspace(down, up, latNumber) lonreg2, latreg2 = np.meshgrid(lonreg, latreg) dind = (abs(mesh.zlevs - depth)).argmin() realdepth = mesh.zlevs[dind] level_data, nnn = pf.get_data(flf.variables[variable][sstep], mesh, realdepth) if interp == 'nn': ofesom = pf.fesom2regular(level_data, mesh, lonreg2, latreg2, radius_of_influence=radius_of_influence) elif interp == 'idist': ofesom = pf.fesom2regular(level_data, mesh, lonreg2, latreg2, radius_of_influence=radius_of_influence, how='idist', k=k) elif interp == 'linear': points = np.vstack((mesh.x2, mesh.y2)).T qh = qhull.Delaunay(points) ofesom = LinearNDInterpolator(qh, level_data)((lonreg2, latreg2)) elif interp == 'cubic': points = np.vstack((mesh.x2, mesh.y2)).T qh = qhull.Delaunay(points) ofesom = CloughTocher2DInterpolator(qh, level_data)((lonreg2, latreg2)) if clim: if variable == 'temp': climvar = 'T' elif variable == 'salt': climvar = 'S' else: raise ValueError( 'You have selected --clim/-c option, but variable `{}` is not in climatology. Acceptable values are `temp` and `salt` only.' .format(variable)) #os.path.join(os.path.dirname(__file__), "../") pathToClim = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../data/") print(pathToClim) w = pf.climatology(pathToClim, clim) xx, yy, oclim = pf.clim2regular( w, climvar, lonreg2, latreg2, levels=[realdepth], radius_of_influence=radius_of_influence) oclim = oclim[0, :, :] data = ofesom - oclim else: data = ofesom if mapproj == 'merc': ax = plt.subplot(111, projection=ccrs.Mercator()) elif mapproj == 'pc': ax = plt.subplot(111, projection=ccrs.PlateCarree()) elif mapproj == 'np': ax = plt.subplot(111, projection=ccrs.NorthPolarStereo()) elif mapproj == 'sp': ax = plt.subplot(111, projection=ccrs.SouthPolarStereo()) elif mapproj == 'rob': ax = plt.subplot(111, projection=ccrs.Robinson()) ax.set_extent([left, right, down, up], crs=ccrs.PlateCarree()) if levels: mmin, mmax, nnum = levels nnum = int(nnum) else: mmin = np.nanmin(data) mmax = np.nanmax(data) nnum = 40 data_levels = np.linspace(mmin, mmax, nnum) if ptype == 'cf': mm = ax.contourf(lonreg,\ latreg,\ data, levels = data_levels, transform=ccrs.PlateCarree(), cmap=colormap, extend='both') elif ptype == 'pcm': data_cyc, lon_cyc = add_cyclic_point(data, coord=lonreg) mm = ax.pcolormesh(lon_cyc,\ latreg,\ data_cyc, vmin = mmin, vmax = mmax, transform=ccrs.PlateCarree(), cmap=colormap, ) else: raise ValueError('Inknown plot type {}'.format(ptype)) ax.coastlines(resolution='50m', lw=0.5) ax.add_feature( cfeature.GSHHSFeature(levels=[1], scale='low', facecolor='lightgray')) cb = plt.colorbar(mm, orientation='horizontal', pad=0.03) cb.set_label(flf.variables[variable].units) plt.title('{} at {}m.'.format(variable, realdepth)) plt.tight_layout() if ofile: plt.savefig(ofile, dpi=100) else: plt.show()
# phase images kw = {"vmax": qpi_pbs[dry_masses[1]].pha.max(), "vmin": qpi_pbs[dry_masses[1]].pha.min()} ax1 = plt.subplot2grid((2, 3), (0, 2)) ax1.set_title("{}pg (in PBS)".format(dry_masses[0])) ax1.axis("off") map1 = ax1.imshow(qpi_pbs[dry_masses[0]].pha, **kw) ax2 = plt.subplot2grid((2, 3), (1, 2)) ax2.set_title("{}pg (in PBS)".format(dry_masses[1])) ax2.axis("off") ax2.imshow(qpi_pbs[dry_masses[1]].pha, **kw) # overview plot ax3 = plt.subplot2grid((2, 3), (0, 0), colspan=2, rowspan=2) ax3.set_xlabel("medium refractive index") ax3.set_ylabel("computed dry mass [pg]") for m, c in zip(dry_masses, ["blue", "green"]): ax3.plot(medium_indices, m_abs[m], ls="solid", color=c, label="{}pg absolute".format(m)) ax3.plot(medium_indices, m_rel[m], ls="dashed", color=c, label="{}pg relative".format(m)) ax3.legend() plt.colorbar(map1, ax=ax3, fraction=.048, pad=0.1, label="phase [rad]") plt.tight_layout() plt.subplots_adjust(wspace=.14) plt.show()
if not opts.src is None: sx, sy = map(slons, slats) for name, xpt, ypt, flx in zip(snams, sx, sy, sflxs): if xpt >= 1e30 or ypt >= 1e30: continue if opts.src_mark != '': map.plot(sx, sy, opts.src_color + opts.src_mark, markerfacecolor=None) if flx < 10: flx = 10 p.text(xpt + .001, ypt + .001, name, size=5 + 2 * int(np.round(np.log10(flx))), color=opts.src_color) if not opts.nobar: p.colorbar(shrink=.5, format='%.2f') else: p.subplots_adjust(.05, .05, .95, .95) def mk_arr(val, dtype=np.double): if type(val) is np.ndarray: return val.astype(dtype) return np.array(val, dtype=dtype).flatten() if opts.outfile != '': print('Saving to', opts.outfile) p.savefig(opts.outfile) else: # Add right-click functionality for finding locations/strengths in map. cnt = 1