def _subplot_label(self, axis): layout_num = self.layout_num if self.subplot else 1 if self.sublabel_format and not self.adjoined and layout_num > 0: from mpl_toolkits.axes_grid1.anchored_artists import AnchoredText labels = {} if '{Alpha}' in self.sublabel_format: labels['Alpha'] = int_to_alpha(layout_num - 1) elif '{alpha}' in self.sublabel_format: labels['alpha'] = int_to_alpha(layout_num - 1, upper=False) elif '{numeric}' in self.sublabel_format: labels['numeric'] = self.layout_num elif '{Roman}' in self.sublabel_format: labels['Roman'] = int_to_roman(layout_num) elif '{roman}' in self.sublabel_format: labels['roman'] = int_to_roman(layout_num).lower() at = AnchoredText(self.sublabel_format.format(**labels), loc=3, bbox_to_anchor=self.sublabel_position, frameon=False, prop=dict(size=self.sublabel_size, weight='bold'), bbox_transform=axis.transAxes) at.patch.set_visible(False) axis.add_artist(at) sublabel = at.txt.get_children()[0] self.handles['sublabel'] = sublabel self.handles['bbox_extra_artists'] += [sublabel]
def draw_text(ax): from mpl_toolkits.axes_grid1.anchored_artists import AnchoredText at = AnchoredText( "Figure 1a", loc=2, prop=dict(size=8), frameon=True, ) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") ax.add_artist(at) at2 = AnchoredText("Figure 1(b)", loc=3, prop=dict(size=8), frameon=True, bbox_to_anchor=(0., 1.), bbox_transform=ax.transAxes) at2.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") ax.add_artist(at2)
def lbl(axis, label, size=22): """ Put a figure label in an axis """ at = AnchoredText(label, loc=2, prop=dict(size=size), frameon=True) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.0") #bb = axis.get_yaxis_transform() #at = AnchoredText(label, # loc=3, prop=dict(size=18), frameon=True, # bbox_to_anchor=(-0.5,1),#(-.255, 0.90), # bbox_transform=bb,#axis.transAxes # ) axis.add_artist(at)
def generate_figures(limit): #For each koi in the the search results, to the user-specified limit, for i in range(0, limit, 1): # if the koi is not a false positive, and its period is less than 800 days # so that we can see at least two transits if good_kois[i].koi_disposition != "FALSE POSITIVE": if good_kois[i].koi_period < 800.0: # get the light curve flux, normalize it by dividing by the mean, and the time for each flux data point lcs = good_kois[i].get_light_curves(short_cadence=False, fetch=False, clobber=False) time, data = [], [] # for each light curve file, fill time and data (flux/mean_flux) arrays for lc in lcs: with lc.open() as f: hdu_data = f[1].data time = np.append(time, hdu_data["time"]) data = np.append(data, (hdu_data['pdcsap_flux']) / (np.nanmean(hdu_data["pdcsap_flux"]))) # plot a new figure for plotting the data for this koi plt.figure(figsize=(24, 14)) plt.plot(time, data, label='Normalized Flux') plt.legend() plt.xlabel('Time (days)') plt.ylabel('Normalized Flux for {}'.format( good_kois[i].kepoi_name)) plt.title("Light Curve {}".format(good_kois[i].kepoi_name)) # State some properties of the koi in a caption box KOI_Properties = AnchoredText( "Period: {} days\nFirst Centroid: {} days\nDisposition: {}" .format(round(good_kois[i].koi_period, 1), round(good_kois[i].koi_time0bk, 1), good_kois[i].koi_disposition), loc=2, prop=dict(size=10), frameon=True) KOI_Properties.patch.set_boxstyle( "round, pad = 0.,rounding_size= 0.2") plt.gca().add_artist(KOI_Properties) #plt.show() # ONLY UNCOMMENT THIS LINE IF YOU ARE SURE THERE ARE LESS THAN 20 GENERATED FIGURES. figureName = str('Kepler LC (long cadence) for ') + str( good_kois[i].kepoi_name) + str('.png') #print "(",i+1,")",figureName pylab.savefig('{}.png'.format(figureName)) plt.close() print "Saved ", figureName, " to working directory." print "Finished. Check working directory for saved figures" #, '{}'"#.format(figureName)
def draw_text(ax, txt): """ Add text in right corner that identifies the data """ at = AnchoredText( txt, loc=1, prop=dict(size=13), frameon=True, ) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") ax.add_artist(at)
def plot_gridded(ref, vel, sweep, fsuffix=None, dir=".", shapefiles=None, interactive=True, LatLon=None): # Set up colormaps from matplotlib.colors import BoundaryNorm cmapr = cm.NWSRef cmapr.set_bad('white', 1.0) cmapr.set_under('white', 1.0) cmapv = cm.Carbone42 cmapv.set_bad('white', 1.) cmapv.set_under('black', 1.) cmapv.set_over('black', 1.) normr = BoundaryNorm(np.arange(10, 85, 5), cmapr.N) normv = BoundaryNorm(np.arange(-48, 50, 2), cmapv.N) min_dbz = _radar_parameters['min_dbz_analysis'] xwidth = ref.xg.max() - ref.xg.min() ywidth = ref.yg.max() - ref.yg.min() # Create png file label if fsuffix == None: print( "\n opaws2D.grid_plot: No output file name is given, writing to %s" % "VR_RF_...png") filename = "%s/VR_RF_%2.2d_plot.pdf" % (dir, sweep) else: filename = "%s/VR_RF_%2.2d_%s.pdf" % (dir, sweep, fsuffix.split("/")[1]) fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True, figsize=(25, 14)) # Set up coordinates for the plots if LatLon == None: bgmap = Basemap(projection=_grid_dict['projection'], width=xwidth, \ height=ywidth, resolution='c', lat_0=ref.radar_lat, lon_0=ref.radar_lon, ax=ax1) xoffset, yoffset = bgmap(ref.radar_lon, ref.radar_lat) xg, yg = bgmap(ref.lons, ref.lats) else: bgmap = Basemap(projection=_grid_dict['projection'], width=xwidth, \ height=ywidth, resolution='c', lat_0=LatLon[0], lon_0=LatLon[1], ax=ax1) xoffset, yoffset = bgmap(ref.radar_lon, ref.radar_lat) xg, yg = bgmap(ref.lons, ref.lats) # print xg.min(), xg.max(), xg.shape # print yg.min(), yg.max(), yg.shape xg_2d, yg_2d = np.meshgrid(xg, yg) # print xg.min(), xg_2d[0,0], xg_2d[-1,-1], xg.max(), xg.shape # print yg.min(), yg.max(), yg.shape # fix xg, yg coordinates so that pcolormesh plots them in the center. dx2 = 0.5 * (ref.xg[1] - ref.xg[0]) dy2 = 0.5 * (ref.yg[1] - ref.yg[0]) xe = np.append(xg - dx2, [xg[-1] + dx2]) ye = np.append(yg - dy2, [yg[-1] + dy2]) # REFLECTVITY PLOT if shapefiles: plot_shapefiles(bgmap, shapefiles=shapefiles, counties=_plot_counties, ax=ax1) else: plot_shapefiles(bgmap, counties=_plot_counties, ax=ax1) bgmap.drawparallels(range(10, 80, 1), labels=[1, 0, 0, 0], linewidth=0.5, ax=ax1) bgmap.drawmeridians(range(-170, -10, 1), labels=[0, 0, 0, 1], linewidth=0.5, ax=ax1) im1 = bgmap.pcolormesh(xe, ye, ref.data[sweep], cmap=cmapr, vmin=_ref_scale[0], vmax=_ref_scale[1], ax=ax1) cbar = bgmap.colorbar(im1, location='right') cbar.set_label('Reflectivity (dBZ)') ax1.set_title('Thresholded Reflectivity (Gridded)') bgmap.scatter(xoffset, yoffset, c='k', s=50., alpha=0.8, ax=ax1) at = AnchoredText( "Max dBZ: %4.1f" % (ref.data[sweep].max()), loc=4, prop=dict(size=12), frameon=True, ) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") ax1.add_artist(at) # Plot zeros as "o" try: r_mask = (ref.zero_dbz.mask == False) print("\n Plotting zeros from MRMS level\n") bgmap.scatter(xg_2d[r_mask], yg_2d[r_mask], s=25, facecolors='none', \ edgecolors='k', alpha=1.0, ax=ax1) except AttributeError: print("\n Plotting zeros from full 3D grid level (non-MRMS form)\n") r_mask = np.logical_and(ref.data[sweep] < 1.0, (ref.data.mask[sweep] == False)) bgmap.scatter(xg_2d[r_mask], yg_2d[r_mask], s=25, facecolors='none', \ edgecolors='k', alpha=1.0, ax=ax1) # RADIAL VELOCITY PLOT if LatLon == None: bgmap = Basemap(projection=_grid_dict['projection'], width=xwidth, \ height=ywidth, resolution='c', lat_0=ref.radar_lat,lon_0=ref.radar_lon, ax=ax2) xoffset, yoffset = bgmap(ref.radar_lon, ref.radar_lat) else: bgmap = Basemap(projection=_grid_dict['projection'], width=xwidth, \ height=ywidth, resolution='c', lat_0=LatLon[0], lon_0=LatLon[1], ax=ax2) xoffset, yoffset = bgmap(ref.radar_lon, ref.radar_lat) if shapefiles: plot_shapefiles(bgmap, shapefiles=shapefiles, counties=_plot_counties, ax=ax2) else: plot_shapefiles(bgmap, counties=_plot_counties, ax=ax2) bgmap.drawparallels(range(10, 80, 1), labels=[1, 0, 0, 0], linewidth=0.5, ax=ax2) bgmap.drawmeridians(range(-170, -10, 1), labels=[0, 0, 0, 1], linewidth=0.5, ax=ax2) im1 = bgmap.pcolormesh(xe, ye, vel.data[sweep], cmap=cmapv, vmin=_vr_scale[0], vmax=_vr_scale[1], ax=ax2) cbar = bgmap.colorbar(im1, location='right') cbar.set_label('Dealised Radial Velocity (meters_per_second)') ax2.set_title('Thresholded, Unfolded Radial Velocity (Gridded)') bgmap.scatter(xoffset, yoffset, c='k', s=50., alpha=0.8, ax=ax2) at = AnchoredText("Max Vr: %4.1f \nMin Vr: %4.1f " % \ (vel.data[sweep].max(),vel.data[sweep].min()), loc=4, prop=dict(size=12), frameon=True,) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") ax2.add_artist(at) # Now plot locations of nan data v_mask = (vel.data.mask == True) bgmap.scatter(xg_2d[v_mask[sweep]], yg_2d[v_mask[sweep]], c='k', s=1., alpha=0.5, ax=ax2) # Get other metadata....for labeling instrument_name = ref.metadata['instrument_name'] time_start = ncdf.num2date(ref.time['data'][0], ref.time['units']) time_text = time_start.isoformat().replace("T", " ") title = '\nDate: %s Time: %s Z Elevation: %2.2f deg' % ( time_text[0:10], time_text[10:19], ref.elevations[sweep]) plt.suptitle(title, fontsize=24) plt.savefig(filename) if interactive: plt.show()
fig = plt.figure() ax = fig.add_subplot(1, 1, 1) at = AA.AnchoredText( "Figure 1a", loc=2, prop=dict(size=8), frameon=True, ) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") ax.add_artist(at) at2 = AnchoredText("Figure 1(b)", loc=3, prop=dict(size=8), frameon=True, bbox_to_anchor=(0., 1.), bbox_transform=ax.transAxes) at2.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") ax.add_artist(at2) ada = AA.AnchoredDrawingArea(20, 20, 0, 0, loc=1, pad=0., frameon=False) p = Circle((10, 10), 10) ada.da.add_artist(p) ax.add_artist(ada) # draw an ellipse of width=0.1, height=0.15 in the data coordinate ae = AA.AnchoredEllipse(ax.transData, width=0.1, height=0.15, angle=0.,
def Normalize_LightCurves(): # based on user input, declare the operation to acquire the light curve data. print"Working..." lcs = koi.get_light_curves(short_cadence = True, clobber = True) # Initiate empty arrays into which we append data from MAST # time array - used extensively for data plotting and model plotting # flux array - used to build the fluxmean, fluxmean2 arrays # fluxmean(2) arrays - used for data plotting and normalization. # data array - a copy of the fluxmean2 array used for plotting lc data. global time, flux, fluxmean, fluxmean2, data time,data = [],[]#flux,fluxmean,fluxmean2,data =[],[],[],[],[] for lc in lcs: with lc.open() as f: hdu_data=f[1].data time=np.append(time,hdu_data["time"]) #flux=np.append(flux,(hdu_data["pdcsap_flux"])) #fluxmean=np.append(fluxmean, (hdu_data['pdcsap_flux'])/(np.nanmean(hdu_data["pdcsap_flux"]))) # Fluxmean2 is for finding the base intensity of the host star. #fluxmean2=np.append(fluxmean2, (hdu_data['pdcsap_flux'])/(np.nanmean(hdu_data["pdcsap_flux"]))) data = np.append(data, (hdu_data['pdcsap_flux'])/(np.nanmean(hdu_data["pdcsap_flux"]))) print "Complete." print "Generating plot of normalized, preconditioned data." ############################################### ''' Fix all the values in the time array to be numbers on cadence with the time interval of the data. There are several sections in the time array that are huge groups of NaN's. These need to be fixed. For each index in the time array, if it is a nan, re-declare it to be time[i-1]+ (time interval). This should fix all NaN's in the time array. ''' for i in range(len(time)): if np.isnan(time[i]) == True: # point = previous time + time interval time[i] = time[i-1] + (time[5]-time[4]) ################################################### ''' Establish vertical lines in the plot to show the transits by first finding the time values for the centroids of each transit. This is found by by adding the "first observed centriod" (as given by MAST) plus an iteration times the period, for each iteration that goes from 1 to the expected number of transits. The expected number of transits is found by dividing the number of days that Kepler operated for the primary mission, divided by the period of the KOI in question. The number of expected transits will be larger for smaller-period KOI. At each of these "centroid" times, a vertical line is placed on the plot from y = 1 to y = (lowest observed flux value, or "min(y)"). ''' centroids = [] for i in np.arange(0,max(time)/period): nextCentroid = koi.koi_time0bk+i*period if nextCentroid < max(time): centroids = np.append(centroids, nextCentroid) print "centriod list:", centroids try: # state the uncertainty of the duration as what is found by MAST. durationErr1 = round(koi.koi_duration_err1,1) if type(durationErr1) =="NoneType": print "none type for durration error 1" except TypeError: # if the duration error is not given by MAST, take it as the square root of the duration ( in hours). durationErr1 = str("$\pm$ "+str(round(math.sqrt(koi.koi_duration),1))) ############################################### ''' The plot of the normalized light curves: ''' plt.figure(figsize=(24,14)) plt.plot(time,data,label ='Normalized Flux') # a horizontal line that shows the "1" value: plt.hlines(1.0000,min(time), max(time),'r') plt.title("Light Curves for KOI {}".format(koi)) plt.xlabel("BJD minus 2455200 (days)") plt.ylabel("Normalized Flux Intensity") ax = plt.gca() ax.get_xaxis().get_major_formatter().set_useOffset(False) ############################################### ''' The "Characteristics" legend: ''' KOI_Properties = AnchoredText(" Characteristics\nPeriod: {} days\nFirst Centroid: {} days\nDisposition: {}\nDuration: {} {} hours\nKepID: {}".format(round(period,1), round(koi.koi_time0bk,1),koi.koi_disposition,round(koi.koi_duration,2),durationErr1,koi.kepid),loc= 2, prop=dict(size = 10),frameon=True) KOI_Properties.patch.set_boxstyle("round, pad = 0.5,rounding_size= 0.2") plt.gca().add_artist(KOI_Properties) plt.legend() plt.show()
def grid_plot(ref, sweep, plot_filename=None, shapefiles=None, interactive=False): # Set up colormaps from matplotlib.colors import BoundaryNorm cmapr = _ref_ctable cmapr.set_bad('white', 1.0) cmapr.set_under('white', 1.0) normr = BoundaryNorm(_ref_scale, cmapr.N) # Create png file label if plot_filename == None: print( "\n pyROTH.grid_plot: No output file name is given, writing to %s" % "RF_...png") filename = "RF_%2.2d_plot.%s" % (sweep, _plot_format) else: filename = "%s.%s" % (plot_filename, _plot_format) fig, axes = plt.subplots(1, 2, sharey=True, figsize=(18, 10)) # Set up coordinates for the plots sw_lon = ref.lons.min() ne_lon = ref.lons.max() sw_lat = ref.lats.min() ne_lat = ref.lats.max() bgmap = Basemap(projection='lcc', llcrnrlon=sw_lon,llcrnrlat=sw_lat,urcrnrlon=ne_lon,urcrnrlat=ne_lat, \ lat_0=0.5*(ne_lat+sw_lat), lon_0=0.5*(ne_lon+sw_lon), resolution='i', area_thresh=10., ax=axes[0]) xg, yg = bgmap(ref.lons, ref.lats) yg_2d, xg_2d = np.meshgrid(yg, xg) yg_2d = yg_2d.transpose() xg_2d = xg_2d.transpose() # fix xg, yg coordinates so that pcolormesh plots them in the center. dx2 = 0.5 * (xg[1] - xg[0]) dy2 = 0.5 * (yg[1] - yg[0]) xe = np.append(xg - dx2, [xg[-1] + dx2]) ye = np.append(yg - dy2, [yg[-1] + dy2]) # CAPPI REFLECTVITY PLOT if shapefiles: plot_shapefiles(bgmap, shapefiles=shapefiles, counties=_plot_counties, ax=axes[0]) else: plot_shapefiles(bgmap, counties=_plot_counties, ax=axes[0]) # pixelated plot ref_data = ref.data[sweep] # im1 = bgmap.pcolormesh(xe, ye, ref_data, cmap=cmapr, norm=normr, vmin = _ref_min_plot, vmax = _ref_scale.max(), ax=axes[0]) # cbar = bgmap.colorbar(im1,location='right') # cbar.set_label('Reflectivity (dBZ)') # axes[0].set_title('Pixel Reflectivity at Height: %4.1f km' % 0.001*ref.zg[sweep]) # at = AnchoredText("Max dBZ: %4.1f" % (ref_data.max()), loc=4, prop=dict(size=10), frameon=True,) # at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") # axes[0].add_artist(at) # Contour filled plot # bgmap = Basemap(projection='lcc', llcrnrlon=sw_lon,llcrnrlat=sw_lat,urcrnrlon=ne_lon,urcrnrlat=ne_lat, \ # lat_0=0.5*(ne_lat+sw_lat), lon_0=0.5*(ne_lon+sw_lon), resolution='i', area_thresh=10.0, ax=axes[1]) # if shapefiles: # plot_shapefiles(bgmap, shapefiles=shapefiles, counties=_plot_counties, ax=axes[1]) # else: # plot_shapefiles(bgmap, counties=_plot_counties, ax=axes[1]) # im1 = bgmap.contourf(xg_2d, yg_2d, ref_data, levels= _ref_scale, cmap=cmapr, norm=normr, \ vmin = _ref_min_plot, vmax = _ref_scale.max(), ax=axes[0]) cbar = bgmap.colorbar(im1, location='right') cbar.set_label('Reflectivity (dBZ)') axes[0].set_title('Reflectivity at Height: %4.1f km' % (0.001 * ref.zg[sweep])) at = AnchoredText( "Max dBZ: %4.1f" % (ref_data.max()), loc=4, prop=dict(size=10), frameon=True, ) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") axes[0].add_artist(at) # COMPOSITE PLOT ref_data = ref.data.max(axis=0) zero_dbz = ref.zero_dbz.data bgmap = Basemap(projection='lcc', llcrnrlon=sw_lon,llcrnrlat=sw_lat,urcrnrlon=ne_lon,urcrnrlat=ne_lat, \ lat_0=0.5*(ne_lat+sw_lat), lon_0=0.5*(ne_lon+sw_lon), resolution='i', area_thresh=10.0, ax=axes[1]) if shapefiles: plot_shapefiles(bgmap, shapefiles=shapefiles, counties=_plot_counties, ax=axes[1]) else: plot_shapefiles(bgmap, counties=_plot_counties, ax=axes[1]) # pixelated plot # im1 = bgmap.pcolormesh(xe, ye, ref_data, cmap=cmapr, norm=normr, vmin = _ref_min_plot, vmax = _ref_scale.max(), ax=axes[2]) # cbar = bgmap.colorbar(im1,location='right') # cbar.set_label('Reflectivity (dBZ)') # axes[2].set_title('Pixel Composite Reflectivity at Height: %4.1f km' % 0.001*ref.zg[sweep]) # at = AnchoredText("Max dBZ: %4.1f" % (ref_data.max()), loc=4, prop=dict(size=10), frameon=True,) # at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") # axes[2].add_artist(at) # contoured plot # bgmap = Basemap(projection='lcc', llcrnrlon=sw_lon,llcrnrlat=sw_lat,urcrnrlon=ne_lon,urcrnrlat=ne_lat, \ # lat_0=0.5*(ne_lat+sw_lat), lon_0=0.5*(ne_lon+sw_lon), resolution='i', area_thresh=10.0, ax=axes[3]) # if shapefiles: # plot_shapefiles(bgmap, shapefiles=shapefiles, counties=_plot_counties, ax=axes[3]) # else: # plot_shapefiles(bgmap, counties=_plot_counties, ax=axes[3]) im1 = bgmap.contourf(xg_2d, yg_2d, ref_data, levels= _ref_scale, cmap=cmapr, norm=normr, \ vmin = _ref_min_plot, vmax = _ref_scale.max(), ax=axes[1]) cbar = bgmap.colorbar(im1, location='right') cbar.set_label('Reflectivity (dBZ)') axes[1].set_title('Composite Reflectivity') at = AnchoredText( "Max dBZ: %4.1f" % (ref_data.max()), loc=4, prop=dict(size=10), frameon=True, ) at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") axes[1].add_artist(at) # Plot zeros as "o" if zero_dbz != None: r_mask = (zero_dbz.mask == False) print("\n Number of zero reflectivity obs found: %d" % np.sum(r_mask)) bgmap.scatter(xg_2d[r_mask], yg_2d[r_mask], s=15, facecolors='none', \ edgecolors='k', alpha=0.3, ax=axes[1]) # Get other metadata....for labeling time_text = ref.time.strftime('%Y-%m-%d %H:%M') title = '\nDate: %s Time: %s' % (time_text[0:10], time_text[10:19]) plt.suptitle(title, fontsize=18) plt.savefig(filename) if interactive: plt.show()