def hp_fits(num_v, ths, phs, nside=64, toy=False): xs = FB8Distribution.spherical_coordinates_to_nu(ths, phs) z, x, y = xs.T s_index = np.random.choice(xs.shape[0], 10000, replace=False) s_ths = [ths[i] for i in s_index] s_phs = [phs[i] for i in s_index] fit8 = fb8_mle(xs, True) hp_plot_fb8(fit8, nside) hp.projscatter(s_ths, s_phs, marker='.', linewidths=0, s=5, c='k') ax = plt.gca() ax.annotate(r"$\bf{-180^\circ}$", xy=(1.7, 0.625), size="medium") ax.annotate(r"$\bf{180^\circ}$", xy=(-1.95, 0.625), size="medium") ax.annotate("Galactic", xy=(0.8, -0.05), size="medium", xycoords="axes fraction") if toy: plt.savefig('figs/{}_toy_fb8.pdf'.format(num_v)) else: plt.savefig('figs/{}_fb8.pdf'.format(num_v)) plt.clf() plt.close('all') gc.collect() return fit8
def animation_path(sched,rot,title,*args, **kwargs): vid_title = "videos/"+title + ".mp4" hpy.mollview(title=title,rot=rot) hpy.graticule(verbose=0) points = hpy.projscatter(np.pi/2-sched[:,1],sched[:,0],lonlat=False,cmap="hsv",c=np.arange(np.size(sched,0)),*args, **kwargs) offto = points.get_offsets() arrayto = points.get_array() climto = points.get_clim() cmapto = points.get_cmap() plt.clf() hpy.mollview(title=title,rot=rot) hpy.graticule(verbose=0) points = hpy.projscatter([],[],lonlat=False,*args, **kwargs) fig = points.get_figure() points.set_clim(climto) points.set_cmap(cmapto) def animate(i,data,color): start_data = max(0,i-300) # start_data = 0 points.set_offsets(data[start_data:i,:]) points.set_array(color[start_data:i]) return points, anim = animation.FuncAnimation(fig, animate,fargs=(offto,arrayto),frames=np.size(offto,0), interval=20, blit=True) anim.save(vid_title)
def hp_fits(ths, phs, nside=64): import healpy as hp xs = FB8Distribution.spherical_coordinates_to_nu(ths, phs) z, x, y = xs.T fit5 = fb8_mle(xs, True, fb5_only=True) hp_plot_fb8(fit5, nside) hp.projscatter(ths, phs, marker='.', linewidths=0, s=5, c='k') ax = plt.gca() ax.annotate(r"$\bf{-180^\circ}$", xy=(1.7, 0.625), size="medium") ax.annotate(r"$\bf{180^\circ}$", xy=(-1.95, 0.625), size="medium") ax.annotate("Galactic", xy=(0.8, -0.05), size="medium", xycoords="axes fraction") plt.savefig('figs/Fig5_fb5.png') fit8 = fb8_mle(xs, True) hp_plot_fb8(fit8, nside) hp.projscatter(ths, phs, marker='.', linewidths=0, s=5, c='k') ax = plt.gca() ax.annotate(r"$\bf{-180^\circ}$", xy=(1.7, 0.625), size="medium") ax.annotate(r"$\bf{180^\circ}$", xy=(-1.95, 0.625), size="medium") ax.annotate("Galactic", xy=(0.8, -0.05), size="medium", xycoords="axes fraction") plt.savefig('figs/Fig5_fb8.png')
def graphtargets(info, targets, skymap): "Generate a graph with the targets generated over the sky map" import healpy as hp from io import BytesIO import matplotlib.pyplot as plt aligo_banana = hp.read_map(skymap) numfig = 1 fig = plt.figure(numfig, figsize=(10, 5)) graph_title = "{} -{}-{}\nBayestar Prob. Sky Map with Targets".format( info["graceid"], info["pkt_ser_num"], info["alerttype"]) hp.mollview( aligo_banana, title=graph_title, flip="astro", unit="$\Delta$", fig=numfig, cmap=plt.cm.gist_heat_r, ) fig.axes[1].texts[0].set_fontsize(8) for obs in targets: ra_pointings = np.array(obs["targets"]["RA"]) dec_pointings = np.array(obs["targets"]["Dec"]) hp.projscatter(ra_pointings, dec_pointings, lonlat=True, color="green", marker=".") hp.graticule() graphIO = BytesIO() plt.savefig(graphIO) return graphIO.getvalue()
def compute_visibility(self): # coord=SkyCoord(ra.flatten(),dec.flatten(),unit=u.deg) # m=Visibility().for_time("2016-10-09T17:31:06",coord=coord) # figure(figsize=(20,10)) # scatter(ra,dec,s=100,c=m,lw=0,alpha=0.4) visibility = Visibility() gwm = healpy.read_map(rootd + "/" + self.skymap) nsides = healpy.npix2nside(gwm.shape[0]) vmap = visibility.for_time(self.utc, nsides=nsides) healpy.mollview( gwm * (vmap * 2 - 1), title="visibility for INTEGRAL due to sun constrains\n" + self.utc) healpy.projscatter(self.ra, self.dec, lonlat=True) healpy.graticule() plot.plot(self.dir + "/visibility.png") healpy.write_map(self.dir + "/visibility.fits", vmap) source_theta = (90 - self.dec) / 180 * pi source_phi = (self.ra) / 180 * pi visibility = dict(probability_visible=sum(gwm * vmap), source_visible=vmap[healpy.ang2pix( nsides, source_theta, source_phi)]) json.dump(visibility, open(self.dir + "/visibility.json", "w"))
def plot_procedure(given_coords, given_color): gala_coords = equatorial2galactic(given_coords) hp.projscatter( gala_coords[:,0], gala_coords[:,1], \ lonlat = True, \ s=1, \ c = given_color, \ )
def plot_galaxies_and_density(t, p, M): """Plots galaxies and pixels from polar form.""" plt.figure(1, dpi=100) hp.mollview(M, fig=1, nest=True, title='Density') plt.figure(2, dpi=100) hp.mollview(M*0-1, fig=2, nest=True, cbar=False, cmap=cm.binary, min=-1, max=1, title='Galaxies') hp.projscatter(t, p, marker='.', facecolor='white', s=0.1, alpha=0.9)
def plot_zoom_with_bg_scatter(self, ind, reso=20): self.plot_zoom_from_map(ind, reso=reso) bg = self.background(ind) zero_msk = np.asarray(bg['ts_prior']) == 0. non_zero_ra = np.asarray(bg['ra'])[~zero_msk] non_zero_dec = np.asarray(bg['dec'])[~zero_msk] hp.projscatter(np.pi / 2. - non_zero_dec, non_zero_ra, marker='x', alpha=0.5, color=sns.xkcd_rgb['battleship grey'])
def selectcenter(hpmap, center, delta=3, nside=256, nest=False, threshold=3, displaycenters=False, doplot=False): #return the pixel of the central peak npix = 12 * nside**2 centerarr = [ center, center - delta * np.array([1, 0]), #center - 2 * delta * np.array([1,0]), center + delta * np.array([1, 0]), #center + 2 * delta * np.array([1,0]), center - delta * np.array([0, 1]), #center - 2 * delta * np.array([0,1]), center + delta * np.array([0, 1]) ] #center + 2 * delta * np.array([0,1])] fullvec = hp.pix2vec(nside, range(0, npix), nest=nest) relmaxpx = np.zeros((len(centerarr), )) px = np.zeros((len(centerarr), ), dtype=int) for j, icenter in enumerate(centerarr): ivec = hp.ang2vec(np.deg2rad(icenter[0]), np.deg2rad(icenter[1])) imaskpx = np.rad2deg(np.arccos(np.dot(ivec, fullvec))) < threshold imaskidx = np.where(imaskpx == True)[0] relmaxpx[j] = np.max(hpmap[imaskpx]) px[j] = imaskidx[np.argmax(hpmap[imaskpx])] indxmax = np.argmax(relmaxpx) pixmax, newcenter = px[indxmax], centerarr[indxmax] if doplot: hp.gnomview(hpmap, reso=12, rot=np.array([90, 0]) - newcenter, nest=nest) if displaycenters: for each in centerarr: hp.projscatter(np.deg2rad(each), marker='+', color='r') hp.projscatter(hp.pix2ang(256, pixmax, nest=nest), marker='+', color='r') return pixmax, newcenter
def plot_map_withsources(positionalmap,foregrounds): ps_x=[] ps_y=[] for j in range(np.shape(positionalmap)[0]): if positionalmap[j]==1: ps_x.append(hp.pix2ang(2048,j)[0]) ps_y.append(hp.pix2ang(2048,j)[1]) hp.mollview(foregrounds,cmap=plt.get_cmap('Blues'),max=4,min=-0.2,title='')#, title='PS detection in map, thrs='+str(threshold)) hp.projscatter(ps_x,ps_y,s=5,color='green') hp.visufunc.graticule(dpar=15, dmer=30) print('Number of detections: '+str(len(ps_x))) plt.savefig('mollplanck75-98.png', format='png', dpi=300)
def plot_cats(cats_path_list, cats_name_list, output_path): color = 'mcrbgk' #fig = plt.figure(1, figsize=(8, 5)) #hp.mollview(title='Galaxy Groups', fig=1, coord='G') #hp.graticule(dpar=30., dmer=30., coord='C') for i in range(len(cats_path_list)): cats_path = cats_path_list[i] cats_name = cats_name_list[i] fig = plt.figure(i + 1, figsize=(8, 5)) hp.mollview(title=cats_name.replace('_', ' '), fig=i + 1, coord='G') hp.graticule(dpar=30., dmer=30., coord='C') ga = GAMA_CAT(cats_path) ga.catalog = cats_name s = 5 if cats_name == 'galcat_6dFGPCM.dat': #ga.mask_bad(ga.catalog['NMEM'] ) ga.mask_bad(ga.catalog['Z'] < 0.01) #ga.mask_bad(ga.catalog['NMEM']>1) #ga.mask_bad(ga.catalog['LOGHALOMASS']>14) s = ga.catalog['NMEM'] * 5 ga.rm_masked() radec = np.concatenate( [ga.catalog['RA'][None, :], ga.catalog['DEC'][None, :]], axis=0) hp.projscatter(radec, lonlat=True, coord=['C', 'G'], edgecolors=None, c=color[i], s=s, alpha=0.1) z1 = ga.cmbrest_to_heliocentric(l_helio=263.85, b_helio=48.25, v_helio=368.) z2 = ga.cmbrest_to_heliocentric(l_helio=263.85, b_helio=48.25, v_helio=368.) print(z1 - z2).max() print(z1 - z2).min() plt.savefig(output_path + cats_name.replace('.dat', '.png')) plt.show()
def plot_map_with_bg_scatter(self, ind): skymap = self.cascade_info['skymap'][ind] hp.mollview(skymap, title=f"Run {self.cascade_info['run'][ind]} " \ + f"Event {self.cascade_info['event'][ind]}", unit='Prob.') hp.graticule(dmer=30, dpar=30) bg = self.background(ind) zero_msk = np.asarray(bg['ts_prior']) == 0. non_zero_ra = np.asarray(bg['ra'])[~zero_msk] non_zero_dec = np.asarray(bg['dec'])[~zero_msk] hp.projscatter(np.pi / 2. - non_zero_dec, non_zero_ra, s=5, marker='x', alpha=0.5, color=sns.xkcd_rgb['battleship grey'])
def true_image_overlay(self, location, utc_date): """Plot current sky. Theta is colatitude and measured from North pole. 0 .. pi (straight up) | el: pi/2 | theta 0 (horizon) | el: 0 | theta pi/2 Th = pi/2 - el flip : {'astro', 'geo''}, optional Defines the convention of projection : 'astro'' (default, east towards left, west towards right) or 'geo' (east towards right, west towards left) """ l_el, l_az, l_name = self.get_src_positions(location, utc_date) th = np.pi / 2.0 - np.array(l_el) l_phi = -np.array(l_az) # _ = [hp.projtext(i, j, n, rot=(0,90,0), color='black', weight='light', ha='left', va='center') for i, j, n in zip(th, l_phi, l_name)] _ = [ hp.projtext( i, j, n, rot=(0, 90, 0), color="gray", alpha=0.8, weight="bold", ha="center", va="bottom", ) for i, j, n in zip(th, l_phi, l_name) ] _ = [ hp.projscatter(i, j, rot=(0, 90, 0), color="black", alpha=1.0, s=25) for i, j, n in zip(th, l_phi, l_name) ] _ = [ hp.projscatter(i, j, rot=(0, 90, 0), color="white", alpha=1.0, s=10) for i, j, n in zip(th, l_phi, l_name) ] hp.projtext(np.pi / 2, 0.0, "N", rot=(0, 90, 0), va="top", ha="center") hp.projtext(np.pi / 2, -np.pi / 2.0, "E", rot=(0, 90, 0), va="center") hp.projtext(np.pi / 2, -np.pi, "S", rot=(0, 90, 0), ha="center") hp.projtext( np.pi / 2, -np.pi * 3.0 / 2.0, "W", rot=(0, 90, 0), ha="right", va="center" )
def check_map(self, catalog=None, ra=None, dec=None): if self.mask is not None: fig = plt.figure(1, figsize=(8, 5)) hp.mollview(self.mask, title='MASK', fig=1, coord='G') hp.graticule(dpar=30., dmer=30., coord='C') fig.delaxes(fig.axes[1]) if self.kSZ_map is not None: fig = plt.figure(2, figsize=(8, 5)) hp.mollview(self.kSZ_map, title='kSZ', fig=2, coord='G') hp.graticule(dpar=30., dmer=30., coord='C') if catalog is not None: radec = np.concatenate( [catalog['RA'][None, :], catalog['DEC'][None, :]], axis=0) hp.projscatter(radec, lonlat=True, coord=['C', 'G'], edgecolors=None, c='r', alpha=0.01, s=10) if ra is not None and dec is not None: radec = np.concatenate([ra[None, :], dec[None, :]], axis=0) hp.projscatter(radec, lonlat=True, coord='G', edgecolors=None, c='k', alpha=0.01, s=10) if self.kSZ_noise is not None: fig = plt.figure(3, figsize=(8, 5)) hp.mollview(self.kSZ_noise, title='kSZ noise', fig=3, coord='G') hp.graticule(dpar=30., dmer=30., coord='E') if self.random_map is not None: fig = plt.figure(4, figsize=(8, 5)) print self.random_map[1000:1020] hp.mollview(self.random_map, title='random', fig=4, coord='G') hp.graticule(dpar=30., dmer=30., coord='C')
def plotEq(): hp.mollview(title="SwiftBAT 70 month Seyfert-0 Catalogue") hp.graticule(coord='C', color='DimGrey') hp.projscatter(ra, dec, coord='C') horizon = 90. hp.projtext(np.pi / 2, 0.15, s='0$^\circ$', color='DimGrey') hp.projtext(np.pi / 2, 2 * np.pi - 0.05, color='DimGrey', s='360$^\circ$') ras = np.arange(0., 361., 1.) * np.pi / 180. decls_1 = np.ones(len(ras)) * (180. - horizon) * np.pi / 180. hp.projplot(decls_1, ras, color='DimGrey', linewidth=1., alpha=0.5, coord='G') hp.projscatter(0.0, 0.0, color='DimGrey', marker='s', coord='G', lonlat=True)
def plot_map_withsources(positionalmap,foregrounds): """ Creates and plots the map where point sources (detections, undetected and spurious) are plotted in their respective positions. """ true_ps_x=[] spur_ps_x=[] nondetected_ps_x=[] true_ps_y=[] spur_ps_y=[] nondetected_ps_y=[] for j in range(np.shape(positionalmap)[0]): if positionalmap[j]==2: true_ps_x.append(hp.pix2ang(2048,j)[0]) true_ps_y.append(hp.pix2ang(2048,j)[1]) if positionalmap[j]==1: nondetected_ps_x.append(hp.pix2ang(2048,j)[0]) nondetected_ps_y.append(hp.pix2ang(2048,j)[1]) if positionalmap[j]==-1: spur_ps_x.append(hp.pix2ang(2048,j)[0]) spur_ps_y.append(hp.pix2ang(2048,j)[1]) hp.mollview(foregrounds,cmap=plt.get_cmap('Blues'),max=4,min=-0.2,title='')#, title='PS location, t='+str(threshold)+r',$ S_{min}=$'+str(fluxjy)+' Jy') hp.projscatter(true_ps_x,true_ps_y,s=5,color='green') hp.projscatter(spur_ps_x,spur_ps_y,s=5,color='red') hp.visufunc.graticule(dpar=15, dmer=30) hp.projscatter(nondetected_ps_x,nondetected_ps_y,s=5,color='yellow') plt.savefig('pslocationscnn2.svg', format='svg') plt.savefig('pslocationscnn2.png', format='png', dpi=400) print('Number of true detections: '+str(len(true_ps_x))) print('Number of spurious: '+str(len(spur_ps_x))) print('Number of non-detected: '+str(len(nondetected_ps_x))) print('Completeness: '+str(len(true_ps_x)/(len(true_ps_x)+len(nondetected_ps_x))))
def _plot_onemap(filemaps, az, el, phth, proj_name, makerotation=False, angs=None): indxmap = 0 if proj_name == "flat": plt.title("Checking coord. of peaks and display of map.") plt.imshow(filemaps[indxmap, :, :], extent=[np.max(az), np.min(az), np.min(el), np.max(el)]) plt.plot(np.degrees(phth[0][indxmap, :]), np.degrees(phth[1][indxmap, :]), color='r', marker='.', linestyle='') elif proj_name == "healpix": hp.gnomview( filemaps[indxmap], min=0, cbar=False, #rot = (azcen_fov, elcen_fov), title='Checking coord. of peaks and display of map', reso=10, rot=(0, 50)) hp.projscatter(phth[1][indxmap, :], phth[0][indxmap, :], color='r', marker='.') hp.graticule(verbose=0, alpha=0.4) plt.show() return
def true_image_overlay(self, location, utc_date): '''Plot current sky. Theta is colatitude and measured from North pole. 0 .. pi (straight up) | el: pi/2 | theta 0 (horizon) | el: 0 | theta pi/2 Th = pi/2 - el flip : {'astro', 'geo''}, optional Defines the convention of projection : 'astro'' (default, east towards left, west towards right) or 'geo' (east towards right, west towards left) ''' l_el, l_az, l_name = self.get_src_positions(location, utc_date) th = np.pi/2. - np.array(l_el) l_phi = -np.array(l_az) #_ = [hp.projtext(i, j, n, rot=(0,90,0), color='black', weight='light', ha='left', va='center') for i, j, n in zip(th, l_phi, l_name)] _ = [hp.projtext(i, j, n, rot=(0,90,0), color='gray', alpha=0.8, weight='bold', ha='center', va='bottom') for i, j, n in zip(th, l_phi, l_name)] _ = [hp.projscatter(i, j, rot=(0,90,0), color='black', alpha=1.0, s=25) for i, j, n in zip(th, l_phi, l_name)] _ = [hp.projscatter(i, j, rot=(0,90,0), color='white', alpha=1.0, s=10) for i, j, n in zip(th, l_phi, l_name)] hp.projtext(np.pi/2, 0., 'N', rot=(0,90,0), va='top', ha='center') hp.projtext(np.pi/2, -np.pi/2., 'E', rot=(0,90,0), va='center') hp.projtext(np.pi/2, -np.pi, 'S', rot=(0,90,0), ha='center') hp.projtext(np.pi/2, -np.pi*3./2., 'W', rot=(0,90,0), ha='right', va='center')
def plot_events(dec, ra, sigmas, src_ra, src_dec, reso, sigma_scale=5., col='k', constant_sigma=False, same_marker=False, energy_size=False, with_mark=True, with_dash=False, label=''): """Adds events to a healpy zoom, get events from llh.""" cos_ev = np.cos(dec) tmp = np.cos(src_ra - ra) * np.cos(src_dec) * cos_ev + np.sin(src_dec) * np.sin(dec) dist = np.arccos(tmp) if sigma_scale is not None: sigma = np.degrees(sigmas) / sigma_scale sizes = 5200 * sigma**2 if constant_sigma: sizes = 20 * np.ones_like(sizes) if with_dash: hp.projscatter(np.pi / 2 - dec, ra, marker='o', linewidth=2, edgecolor=col, linestyle=':', facecolor="None", s=sizes, alpha=1.0) else: hp.projscatter(np.pi / 2 - dec, ra, marker='o', linewidth=2, edgecolor=col, facecolor="None", s=sizes, alpha=1.0) if with_mark: hp.projscatter(np.pi / 2 - dec, ra, marker='x', linewidth=2, edgecolor=col, facecolor=col, s=60, alpha=1.0)
dec_gtest=(5,-5,5,-5) ra_ctest=(265,265,255,255) dec_ctest=(-35,-25,-35,-25) #This is the actual plotting part #If you don't specify, it's in equatorial #Rot = 180 shifts the axis from the center to the edge #centered by default hp.mollview(title = 'Equatorial Map of SwiftBAT AGNs', cbar = False, rot = 180, notext = False, cmap=None,coord='C') hp.graticule(coord='C', color='DimGrey') #hp.graticule(coord='G', color='DimGrey') py.title("SwiftBAT 70 month Seyfert-0 Catalogue - Equatorial") #hp.projscatter(ra,dec,coord='C',lonlat=True) hp.projscatter(ra_ctest,dec_ctest, coord='C',lonlat=True) hp.projtext(185, 2,'180', lonlat=True, fontweight = 'bold') hp.projtext(95, 2, '90', lonlat=True, fontweight = 'bold') hp.projtext(275, 2, '270', lonlat=True, fontweight = 'bold') hp.projtext(8, 2,'0', lonlat=True, fontweight = 'bold') hp.projtext(359, 2, '360', lonlat=True, fontweight = 'bold') hp.projtext(193, -8, 'RA (deg)', lonlat=True, fontweight = 'bold') hp.projtext(350, 30, '30', lonlat=True, fontweight = 'bold') hp.projtext(340, 60, '60', lonlat=True, fontweight = 'bold') #hp.projtext(5, -5, 'Dec (deg)', lonlat=True) hp.projtext(358, -33.5, '-30', lonlat=True, fontweight = 'bold') hp.projtext(358, -63.5, '-60', lonlat=True, fontweight = 'bold') ra_gplane = np.arange(0.,361.,1.) dec_gplane = np.ones(len(ra_gplane))*(90) hp.projplot(dec_gplane,ra_gplane, rot=180, coord='G', lonlat=True, color='DimGrey', linewidth=2., alpha=0.5) py.savefig('/home/relethford/Documents/IceCube_Research/Plots/AGNCore/X-Ray_Catalogue/SwiftBAT_70M/equatorialmap.png')
print(llh) # iterator of all-sky scan with follow up scans of most interesting points for i, (scan, hotspot) in enumerate(llh.all_sky_scan(nside=16, pVal=pVal_func, decRange=np.radians([-90.0, 90.0]))): if i > 0: # break after first follow up break # plot results hp.mollview(scan["pVal"], min=0.0, cmap=plt.cm.afmhot, rot=[-180.0, 0.0, 0.0]) if isinstance(llh, MultiPointSourceLLH): for llh in llh._sams.itervalues(): hp.projscatter( np.degrees(llh.exp["ra"]), np.degrees(np.arcsin(llh.exp["sinDec"])), rot=[-180.0, 0.0, 0.0], lonlat=True, marker="x", color=plt.gca()._get_lines.color_cycle.next(), ) else: hp.projscatter( np.degrees(llh.exp["ra"]), np.degrees(np.arcsin(llh.exp["sinDec"])), rot=[-180.0, 0.0, 0.0], lonlat=True, marker="x", color="red", ) plt.show()
def searchByDistance(nside, data, distance_modulus, ra_select, dec_select, magnitude_threshold=24.5, plot=False, fracdet=None): """ Idea: Send a data extension that goes to faint magnitudes, e.g., g < 24. Use the whole region to identify hotspots using a slightly brighter magnitude threshold, e.g., g < 23, so not susceptible to variations in depth. Then compute the local field density using a small annulus around each individual hotspot, e.g., radius 0.3 to 0.5 deg. plot = True enables diagnostic plotting for testings fracdet corresponds to a fracdet map (numpy array, assumed to be EQUATORIAL and RING) """ SCALE = 2.75 * (healpy.nside2resol(nside, arcmin=True) / 60.) # deg, scale for 2D histogram and various plotting print('Distance = %.1f kpc (m-M = %.1f)'%(ugali.utils.projector.distanceModulusToDistance(distance_modulus), distance_modulus)) dirname = '/home/s1/kadrlica/.ugali/isochrones/des/dotter2016/' #dirname = '/Users/keithbechtol/Documents/DES/projects/mw_substructure/ugalidir/isochrones/des/dotter2016/' iso = ugali.isochrone.factory('Dotter', hb_spread=0, dirname=dirname) iso.age = 12. iso.metallicity = 0.0001 iso.distance_modulus = distance_modulus cut = cutIsochronePath(data[mag_g_dred_flag], data[mag_r_dred_flag], data[mag_err_g_flag], data[mag_err_r_flag], iso, radius=0.1) data = data[cut] cut_magnitude_threshold = (data[mag_g_dred_flag] < magnitude_threshold) print('%i objects left after isochrone cut...'%(len(data))) ### proj = ugali.utils.projector.Projector(ra_select, dec_select) x, y = proj.sphereToImage(data['RA'][cut_magnitude_threshold], data['DEC'][cut_magnitude_threshold]) # Trimmed magnitude range for hotspot finding x_full, y_full = proj.sphereToImage(data['RA'], data['DEC']) # In we want to use full magnitude range for significance evaluation delta_x = 0.01 area = delta_x**2 smoothing = 2. / 60. # Was 3 arcmin bins = np.arange(-1. * SCALE, SCALE + 1.e-10, delta_x) centers = 0.5 * (bins[0: -1] + bins[1:]) yy, xx = np.meshgrid(centers, centers) h = np.histogram2d(x, y, bins=[bins, bins])[0] if plot: #pylab.figure('raw') #pylab.clf() #pylab.imshow(h.T, interpolation='nearest', extent=[-1. * SCALE, SCALE, -1. * SCALE, SCALE], origin='lower', cmap='binary') #pylab.xlim([SCALE, -1. * SCALE]) #pylab.ylim([-1. * SCALE, SCALE]) #pylab.colorbar() ##import skymap ##s = skymap.Skymap(projection='laea',llcrnrlon=340,llcrnrlat=-60,urcrnrlon=360,urcrnrlat=-50,lon_0 =355,lat_0=-55,celestial=False) ##s.draw_hpxmap(fracdet) #pix = skymap.healpix.ang2disc(355,-63,1) #pix = skymap.healpix.ang2disc(4096,355,-63,1) #s = skymap.Skymap() #s.draw_hpxmap(m[pix],pix,4096) #s.zoom_to_fit() #s.zoom_to_fit(4096,m[pix],pix) reso = 0.25 pylab.figure('gnom') pylab.clf() healpy.gnomview(fracdet, fig='gnom', rot=(ra_select, dec_select, 0.), reso=reso, xsize=(2. * SCALE * 60. / reso), cmap='Greens', title='Fracdet') #binary healpy.projscatter(data['RA'], data['DEC'], edgecolor='none', c='red', lonlat=True, s=2) h_g = scipy.ndimage.filters.gaussian_filter(h, smoothing / delta_x) #cut_goodcoverage = (data['NEPOCHS_G'][cut_magnitude_threshold] >= 2) & (data['NEPOCHS_R'][cut_magnitude_threshold] >= 2) # expect NEPOCHS to be good in DES data delta_x_coverage = 0.1 area_coverage = (delta_x_coverage)**2 bins_coverage = np.arange(-5., 5. + 1.e-10, delta_x_coverage) h_coverage = np.histogram2d(x, y, bins=[bins_coverage, bins_coverage])[0] #h_goodcoverage = np.histogram2d(x[cut_goodcoverage], y[cut_goodcoverage], bins=[bins_coverage, bins_coverage])[0] h_goodcoverage = np.histogram2d(x, y, bins=[bins_coverage, bins_coverage])[0] n_goodcoverage = h_coverage[h_goodcoverage > 0].flatten() #characteristic_density = np.mean(n_goodcoverage) / area_coverage # per square degree characteristic_density = np.median(n_goodcoverage) / area_coverage # per square degree print('Characteristic density = %.1f deg^-2'%(characteristic_density)) # Use pixels with fracdet ~1.0 to estimate the characteristic density if fracdet is not None: fracdet_zero = np.tile(0., len(fracdet)) cut = (fracdet != healpy.UNSEEN) fracdet_zero[cut] = fracdet[cut] nside_fracdet = healpy.npix2nside(len(fracdet)) subpix_region_array = [] for pix in np.unique(ugali.utils.healpix.angToPix(nside, data['RA'], data['DEC'])): subpix_region_array.append(ugali.utils.healpix.subpixel(pix, nside, nside_fracdet)) subpix_region_array = np.concatenate(subpix_region_array) # Compute mean fracdet in the region so that this is available as a correction factor cut = (fracdet[subpix_region_array] != healpy.UNSEEN) mean_fracdet = np.mean(fracdet[subpix_region_array[cut]]) subpix_region_array = subpix_region_array[fracdet[subpix_region_array] > 0.99] subpix = ugali.utils.healpix.angToPix(nside_fracdet, data['RA'][cut_magnitude_threshold], data['DEC'][cut_magnitude_threshold]) # Remember to apply mag threshold to objects characteristic_density_fracdet = float(np.sum(np.in1d(subpix, subpix_region_array))) \ / (healpy.nside2pixarea(nside_fracdet, degrees=True) * len(subpix_region_array)) # deg^-2 print('Characteristic density fracdet = %.1f deg^-2'%(characteristic_density_fracdet)) # Correct the characteristic density by the mean fracdet value characteristic_density_raw = 1. * characteristic_density characteristic_density /= mean_fracdet print('Characteristic density (fracdet corrected) = %.1f deg^-2'%(characteristic_density)) if plot: pylab.figure('poisson') pylab.clf() n_max = np.max(h_coverage) pylab.hist(n_goodcoverage, bins=np.arange(n_max) - 0.5, color='blue', histtype='step', lw=2, normed=True) pylab.scatter(np.arange(n_max), scipy.stats.poisson.pmf(np.arange(n_max), mu=np.median(n_goodcoverage)), c='red', edgecolor='none', zorder=10) #pylab.plot(np.arange(n_max), scipy.stats.poisson.pmf(np.arange(n_max), mu=np.median(n_goodcoverage)), c='red', lw=2, zorder=10) pylab.axvline(characteristic_density * area_coverage, c='black', ls='--') if fracdet is not None: pylab.axvline(characteristic_density_raw * area_coverage, c='orange', ls='--') pylab.axvline(characteristic_density_fracdet * area_coverage, c='green', ls='--') pylab.xlabel('Counts per %.3f deg^-2 pixel'%(area_coverage)) pylab.ylabel('PDF') if plot: vmax = min(3. * characteristic_density * area, np.max(h_g)) pylab.figure('smooth') pylab.clf() pylab.imshow(h_g.T, interpolation='nearest', extent=[-1. * SCALE, SCALE, -1. * SCALE, SCALE], origin='lower', cmap='gist_heat', vmax=vmax) pylab.colorbar() pylab.xlim([SCALE, -1. * SCALE]) pylab.ylim([-1. * SCALE, SCALE]) pylab.xlabel(r'$\Delta$ RA (deg)') pylab.ylabel(r'$\Delta$ Dec (deg)') pylab.title('(RA, Dec, mu) = (%.2f, %.2f, %.2f)'%(ra_select, dec_select, distance_modulus)) factor_array = np.arange(1., 5., 0.05) rara, decdec = proj.imageToSphere(xx.flatten(), yy.flatten()) cutcut = (ugali.utils.healpix.angToPix(nside, rara, decdec) == pix_nside_select).reshape(xx.shape) threshold_density = 5 * characteristic_density * area for factor in factor_array: h_region, n_region = scipy.ndimage.measurements.label((h_g * cutcut) > (area * characteristic_density * factor)) #print 'factor', factor, n_region, n_region < 10 if n_region < 10: threshold_density = area * characteristic_density * factor break h_region, n_region = scipy.ndimage.measurements.label((h_g * cutcut) > threshold_density) h_region = np.ma.array(h_region, mask=(h_region < 1)) if plot: pylab.figure('regions') pylab.clf() pylab.imshow(h_region.T, interpolation='nearest', extent=[-1. * SCALE, SCALE, -1. * SCALE, SCALE], origin='lower') pylab.colorbar() pylab.xlim([SCALE, -1. * SCALE]) pylab.ylim([-1. * SCALE, SCALE]) ra_peak_array = [] dec_peak_array = [] r_peak_array = [] sig_peak_array = [] distance_modulus_array = [] pylab.figure('sig') pylab.clf() for index in range(1, n_region + 1): index_peak = np.argmax(h_g * (h_region == index)) x_peak, y_peak = xx.flatten()[index_peak], yy.flatten()[index_peak] #print index, np.max(h_g * (h_region == index)) if plot: pylab.figure('regions') #pylab.scatter(x_peak, y_peak, marker='x', c='white') pylab.scatter(x_peak, y_peak, marker='o', c='none', edgecolor='black', s=50) #angsep_peak = np.sqrt((x_full - x_peak)**2 + (y_full - y_peak)**2) # Use full magnitude range, NOT TESTED!!! angsep_peak = np.sqrt((x - x_peak)**2 + (y - y_peak)**2) # Impose magnitude threshold # Compute the local characteristic density # If fracdet map is available, use that information to either compute local density, # or in regions of spotty coverage, use the typical density of the region if fracdet is not None: ra_peak, dec_peak = proj.imageToSphere(x_peak, y_peak) subpix_all = ugali.utils.healpix.angToDisc(nside_fracdet, ra_peak, dec_peak, 0.5) subpix_inner = ugali.utils.healpix.angToDisc(nside_fracdet, ra_peak, dec_peak, 0.3) subpix_annulus = subpix_all[~np.in1d(subpix_all, subpix_inner)] mean_fracdet = np.mean(fracdet_zero[subpix_annulus]) print('mean_fracdet', mean_fracdet) if mean_fracdet < 0.5: characteristic_density_local = characteristic_density print('characteristic_density_local baseline', characteristic_density_local) else: # Check pixels in annulus with complete coverage subpix_annulus_region = np.intersect1d(subpix_region_array, subpix_annulus) print(float(len(subpix_annulus_region)) / len(subpix_annulus)) if (float(len(subpix_annulus_region)) / len(subpix_annulus)) < 0.25: characteristic_density_local = characteristic_density print('characteristic_density_local spotty', characteristic_density_local) else: characteristic_density_local = float(np.sum(np.in1d(subpix, subpix_annulus_region))) \ / (healpy.nside2pixarea(nside_fracdet, degrees=True) * len(subpix_annulus_region)) # deg^-2 print('characteristic_density_local cleaned up', characteristic_density_local) else: # Compute the local characteristic density area_field = np.pi * (0.5**2 - 0.3**2) n_field = np.sum((angsep_peak > 0.3) & (angsep_peak < 0.5)) characteristic_density_local = n_field / area_field # If not good azimuthal coverage, revert cut_annulus = (angsep_peak > 0.3) & (angsep_peak < 0.5) #phi = np.degrees(np.arctan2(y_full[cut_annulus] - y_peak, x_full[cut_annulus] - x_peak)) # Use full magnitude range, NOT TESTED!!! phi = np.degrees(np.arctan2(y[cut_annulus] - y_peak, x[cut_annulus] - x_peak)) # Impose magnitude threshold h = np.histogram(phi, bins=np.linspace(-180., 180., 13))[0] if np.sum(h > 0) < 10 or np.sum(h > 0.5 * np.median(h)) < 10: #angsep_peak = np.sqrt((x - x_peak)**2 + (y - y_peak)**2) characteristic_density_local = characteristic_density print('Characteristic density local = %.1f deg^-2'%(characteristic_density_local)) size_array = np.arange(0.01, 0.3, 0.01) sig_array = np.tile(0., len(size_array)) for ii in range(0, len(size_array)): n_peak = np.sum(angsep_peak < size_array[ii]) n_model = characteristic_density_local * (np.pi * size_array[ii]**2) sig_array[ii] = scipy.stats.norm.isf(scipy.stats.poisson.sf(n_peak, n_model)) if sig_array[ii] > 25: sig_array[ii] = 25. # Set a maximum significance value if plot: pylab.figure('sig') pylab.plot(size_array, sig_array) pylab.xlabel('Radius used to compute significance (deg)') pylab.ylabel('Detection significance') ra_peak, dec_peak = proj.imageToSphere(x_peak, y_peak) r_peak = size_array[np.argmax(sig_array)] if np.max(sig_array) == 25.: r_peak = 0.5 #print 'Candidate:', x_peak, y_peak, r_peak, np.max(sig_array), ra_peak, dec_peak print('Candidate: %12.3f %12.3f %12.3f %12.3f %12.3f %12.3f'%(x_peak, y_peak, r_peak, np.max(sig_array), ra_peak, dec_peak)) if np.max(sig_array) > 5.: if plot: x_circle, y_circle = circle(x_peak, y_peak, r_peak) pylab.figure('smooth') pylab.plot(x_circle, y_circle, c='gray') pylab.text(x_peak - r_peak, y_peak + r_peak, r'%.2f $\sigma$'%(np.max(sig_array)), color='gray') ra_peak_array.append(ra_peak) dec_peak_array.append(dec_peak) r_peak_array.append(r_peak) sig_peak_array.append(np.max(sig_array)) distance_modulus_array.append(distance_modulus) if plot: input('Plots are ready...') return ra_peak_array, dec_peak_array, r_peak_array, sig_peak_array, distance_modulus_array
def visualize_map(args): """Visualize sky maps in hdf5 files. Arguments --------- args : argparse namespace. """ import numpy as np import h5py import healpy # import hpvisual import matplotlib matplotlib.use('Agg') try: # for new version matplotlib import matplotlib.style as mstyle mstyle.use('classic') except ImportError: pass from matplotlib import pyplot as plt # Read in maps data hpmap = None for mapname in args.mapfiles: with h5py.File(mapname, 'r') as f: if hpmap is None: hpmap = f['map'][:] else: hpmap += f['map'][:] # Check args validity if args.ifreq < -(hpmap.shape)[0] or args.ifreq >= (hpmap.shape)[0]: raise Exception('Invalid frequency channel %d, should be in range(-%d, %d).'%(args.ifreq, (hpmap.shape)[0], (hpmap.shape)[0])) else: ifreq = args.ifreq if args.ifreq >= 0 else args.ifreq + (hpmap.shape)[0] if args.pol >= (hpmap.shape)[1]: raise Exception('Invalid frequency channel %d, should be in range(0, %d).'%(args.pol, (hpmap.shape)[1])) if args.figlength <= 0: raise Exception('Figure length figlength (= %f) must greater than 0'%args.figlength) if args.figwidth <= 0: raise Exception('Figure width figwidth (= %f) must greater than 0'%args.figwidth) # Create output image file name if args.outfile: out_file = args.outfile else: out_file = ((args.mapfiles[0].split('/')[-1]).split('.')[0] + '_' + str(ifreq) + '_{' + str(args.pol) + '}' + '.' + args.figfmt).format('T', 'Q', 'U', 'V') # Plot and save image if args.view == 'o': fig = plt.figure(1, figsize=(8, 6)) else: fig = plt.figure(1, figsize=(args.figlength,args.figwidth)) map_data = hpmap[ifreq][args.pol] if args.sqrt: map_data = map_data / np.sqrt(np.abs(map_data)) map_data = map_data / np.sqrt(np.abs(map_data)) # map_data = map_data / np.sqrt(np.abs(map_data)) # smoothing the map with a Gaussian symmetric beam if args.fwhm is not None: fwhm = np.radians(args.fwhm) map_data = healpy.smoothing(map_data, fwhm=fwhm) if args.view == 'm': # set color map if args.cmap is None: cmap = None else: if args.cmap == 'jet09': import colormap cmap = colormap.jet09 else: from pylab import cm # cmap = cm.hot cmap = getattr(cm, args.cmap) cmap.set_under('w') if args.abs: healpy.mollview(np.abs(map_data), fig=1, title='', unit=args.unit, cmap=cmap, min=args.min, max=args.max) else: healpy.mollview(map_data, fig=1, title='', unit=args.unit, cmap=cmap, min=args.min, max=args.max) # plot NVSS sources if args.nvss is not None: import aipy as a flux = args.nvss frequency = 750 # MHz catalog = 'nvss' # catalog = 'wenss' src = '%f/%f' % (flux, frequency / 1.0e3) srclist, cutoff, catalogs = a.scripting.parse_srcs(src, catalog) cat = a.src.get_catalog(srclist, cutoff, catalogs) nsrc = len(cat) # number of sources in cat ras = [ np.degrees(cat.values()[i]._ra) for i in range(nsrc) ] decs = [ np.degrees(cat.values()[i]._dec) for i in range(nsrc) ] jys = [ cat.values()[i].get_jys() for i in range(nsrc) ] # select sources inds = np.where(np.array(decs)>-15.0)[0] ras = np.array(ras)[inds] decs = np.array(decs)[inds] jys = np.array(jys)[inds] # healpy.projscatter(ras, decs, lonlat=True, s=jys, facecolors='none', edgecolors='w', alpha=1.0, linewidth=1.0) healpy.projscatter(ras, decs, lonlat=True, s=150, facecolors='none', edgecolors='w', alpha=1.0, linewidth=1.0) elif args.view == 'c': healpy.cartview(map_data, fig=1, title='', unit=args.unit, min=args.min, max=args.max) elif args.view == 'o': healpy.orthview(map_data, rot=(0, 90, 0), fig=1, title='', unit=args.unit, min=args.min, max=args.max, half_sky=True) # rot to make NCP at the center # fig = plt.figure() # ax = fig.add_axes() # cbar.solids.set_rasterized(True) if args.grid: healpy.graticule() if args.tight: fig.savefig(out_file, bbox_inches='tight') else: fig.savefig(out_file) fig.clf()
parser.add_option('-t','--targets',default=None) parser.add_option('-c','--coord',default='GAL') parser.add_option('-p','--proj',default='MOL',choices=['MOL','CAR']) parser.add_option('-f','--field',default='LOG_LIKELIHOOD') (opts, args) = parser.parse_args() nside = pyfits.open(args[0])[1].header['NSIDE'] map = healpy.UNSEEN * numpy.ones( healpy.nside2npix(nside) ) pix,vals = ugali.utils.skymap.readSparseHealpixMap(args[0],opts.field,construct_map=False) map[pix] = vals[0] if opts.coord.upper() == "GAL": coord = 'G' elif opts.coord.upper() == "CEL": coord = 'GC' if opts.proj.upper() == "MOL": healpy.mollview(map,coord=coord,xsize=1000) elif opts.proj.upper() == "CAR": healpy.cartview(map,coord=coord,xsize=1000) else: raise Exception("...") healpy.graticule() if opts.targets: data = numpy.loadtxt(opts.targets,unpack=True,dtype='str') coord = 'CG' # For RA/DEC input healpy.projscatter(data[1].astype(float),data[2].astype(float), lonlat=True,coord=coord,marker='o',c='w') plt.savefig(opts.outfile)
import healpy as hp import numpy as np import pandas as pd import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt from astropy import units as uwell from astropy.coordinates import SkyCoord cat_path = "catalog.csv" rand_cat_path = "random_catalog.csv" sel_func_path = " HFI_PCCS_SZ-selfunc-union-survey_R2.08.fits" title = "Planck Clusters" out_path = "Planck_scatter.pdf" if __name__ == "__main__": catalog = pd.read_csv(cat_path) random_catalog = pd.read_csv(rand_cat_path) ra = np.asarray(catalog["RA"].values) dec = np.asarray(catalog["DEC"].values) rand_ra = np.asarray(random_catalog["RA"].values) rand_dec = np.asarray(random_catalog["DEC"].values) seln_func = hp.read_map(sel_func_path) hp.visufunc.mollview(seln_func, title=title, coord=["G", "C"]) hp.projscatter(ra, dec, lonlat=True, s=3, c='r') #hp.projscatter(rand_ra, rand_dec, lonlat=True, s = 3, c = 'b') hp.graticule() plt.savefig(out_path)
from scipy.stats import chi2 import healpy as hp import numpy as np import matplotlib.pyplot as plt # convert test statistic to a p-value for a given point pVal_func = lambda TS, dec: -np.log10(0.5 * (chi2(1).sf(TS) + chi2(1).cdf(-TS))) if __name__=="__main__": # init the llh class llh = init(1000, 10000, ncpu=1, energy=True) print(llh) # iterator of all-sky scan with follow up scans of most interesting points for i, (scan, hotspot) in enumerate(llh.all_sky_scan(nside=16, pVal=pVal_func)): if i > 0: # break after first follow up break # plot results hp.mollview(scan["pVal"], min=0., cmap=plt.cm.afmhot) hp.projscatter(np.degrees(llh.exp["ra"]), np.degrees(np.arcsin(llh.exp["sinDec"])), lonlat=True, marker="x", color="red") plt.show()
def coverage(params, map_struct, coverage_struct, catalog_struct=None): unit = 'Gravitational-wave probability' cbar = False plotName = os.path.join(params["outputDir"], 'mollview_coverage.pdf') plt.figure() hp.mollview(map_struct["prob"], title='', unit=unit, cbar=cbar, cmap=cmap) hp.projplot(coverage_struct["data"][:, 0], coverage_struct["data"][:, 1], 'wx', lonlat=True, coord='G') add_edges() plt.show() plt.savefig(plotName, dpi=200) plt.close('all') idx = np.isfinite(coverage_struct["data"][:, 4]) if not idx.size: return min_time = np.min(coverage_struct["data"][idx, 4]) max_time = np.max(coverage_struct["data"][idx, 4]) plotName = os.path.join(params["outputDir"], 'coverage.pdf') plt.figure(figsize=(10, 8)) ax = plt.gca() for ii in range(len(coverage_struct["ipix"])): data = coverage_struct["data"][ii, :] filt = coverage_struct["filters"][ii] ipix = coverage_struct["ipix"][ii] patch = coverage_struct["patch"][ii] FOV = coverage_struct["FOV"][ii] if filt == "g": color = "g" elif filt == "r": color = "r" else: color = "k" plt.scatter(data[2], data[5], s=20, color=color) plt.xlabel("Time [MJD]") plt.ylabel("Tile Number") plt.show() plt.savefig(plotName, dpi=200) plt.close('all') plotName = os.path.join(params["outputDir"], 'tiles_coverage.pdf') plt.figure() hp.mollview(map_struct["prob"], title='', unit=unit, cbar=cbar, cmap=cmap) add_edges() ax = plt.gca() for ii in range(len(coverage_struct["ipix"])): data = coverage_struct["data"][ii, :] filt = coverage_struct["filters"][ii] ipix = coverage_struct["ipix"][ii] patch = coverage_struct["patch"][ii] FOV = coverage_struct["FOV"][ii] #hp.visufunc.projplot(corners[:,0], corners[:,1], 'k', lonlat = True) if patch == []: continue patch_cpy = copy.copy(patch) patch_cpy.axes = None patch_cpy.figure = None patch_cpy.set_transform(ax.transData) hp.projaxes.HpxMollweideAxes.add_patch(ax, patch_cpy) #tiles.plot() plt.show() plt.savefig(plotName, dpi=200) plt.close('all') diffs = [] if params["tilesType"] == "galaxy": coverage_ras = coverage_struct["data"][:, 0] coverage_decs = coverage_struct["data"][:, 1] coverage_mjds = coverage_struct["data"][:, 2] for ii in range(len(coverage_ras) - 1): current_ra, current_dec = coverage_ras[ii], coverage_decs[ii] current_mjd = coverage_mjds[ii] dist = angular_distance(current_ra, current_dec, coverage_ras[ii + 1:], coverage_decs[ii + 1:]) idx = np.where(dist <= 1 / 3600.0)[0] if len(idx) > 0: jj = idx[0] diffs.append( np.abs(coverage_struct["data"][ii, 2] - coverage_struct["data"][jj, 2])) else: for ii in range(len(coverage_struct["ipix"])): ipix = coverage_struct["ipix"][ii] for jj in range(len(coverage_struct["ipix"])): if ii >= jj: continue if coverage_struct["telescope"][ii] == coverage_struct[ "telescope"][jj]: continue ipix2 = coverage_struct["ipix"][jj] overlap = np.intersect1d(ipix, ipix2) rat = np.array([ float(len(overlap)) / float(len(ipix)), float(len(overlap)) / float(len(ipix2)) ]) if np.any(rat > 0.5): diffs.append( np.abs(coverage_struct["data"][ii, 2] - coverage_struct["data"][jj, 2])) filename = os.path.join(params["outputDir"], 'tiles_coverage_hist.dat') fid = open(filename, 'w') for ii in range(len(diffs)): fid.write('%.10f\n' % diffs[ii]) fid.close() plotName = os.path.join(params["outputDir"], 'tiles_coverage_hist.pdf') fig = plt.figure(figsize=(12, 8)) #hist, bin_edges = np.histogram(diffs, bins=20) bins = np.linspace(0.0, 24.0, 25) plt.hist(24.0 * np.array(diffs), bins=bins) plt.xlabel('Difference Between Observations [hours]') plt.ylabel('Number of Observations') plt.show() plt.savefig(plotName, dpi=200) plt.close('all') gpstime = params["gpstime"] event_mjd = Time(gpstime, format='gps', scale='utc').mjd colors = cm.rainbow(np.linspace(0, 1, len(params["telescopes"]))) plotName = os.path.join(params["outputDir"], 'tiles_coverage_int.pdf') fig = plt.figure(figsize=(12, 8)) gs = fig.add_gridspec(4, 1) ax1 = fig.add_subplot(gs[0:3, 0], projection='astro hours mollweide') ax2 = fig.add_subplot(gs[3, 0]) ax3 = ax2.twinx() # mirror them plt.axes(ax1) hp.mollview(map_struct["prob"], title='', unit=unit, cbar=cbar, cmap=cmap, hold=True) add_edges() ax = plt.gca() data = {} if params["tilesType"] == "galaxy": for telescope, color in zip(params["telescopes"], colors): idx = np.where(coverage_struct["telescope"] == telescope)[0] hp.projscatter(coverage_struct["data"][idx, 0], coverage_struct["data"][idx, 1], lonlat=True, s=10, color=color) else: for ii in range(len(coverage_struct["ipix"])): data = coverage_struct["data"][ii, :] filt = coverage_struct["filters"][ii] ipix = coverage_struct["ipix"][ii] patch = coverage_struct["patch"][ii] FOV = coverage_struct["FOV"][ii] idx = params["telescopes"].index(coverage_struct["telescope"][ii]) if patch == []: continue #hp.visufunc.projplot(corners[:,0], corners[:,1], 'k', lonlat = True) patch_cpy = copy.copy(patch) patch_cpy.axes = None patch_cpy.figure = None patch_cpy.set_transform(ax.transData) patch_cpy.set_facecolor(colors[idx]) hp.projaxes.HpxMollweideAxes.add_patch(ax, patch_cpy) #tiles.plot() idxs = np.argsort(coverage_struct["data"][:, 2]) plt.axes(ax2) for telescope, color in zip(params["telescopes"], colors): ipixs = np.empty((0, 2)) cum_prob = 0.0 cum_area = 0.0 tts, cum_probs, cum_areas = [], [], [] if params["tilesType"] == "galaxy": cum_galaxies = [] for jj, ii in enumerate(idxs): if np.mod(jj, 100) == 0: print('%s: %d/%d' % (telescope, jj, len(idxs))) data = coverage_struct["data"][ii, :] filt = coverage_struct["filters"][ii] ipix = coverage_struct["ipix"][ii] patch = coverage_struct["patch"][ii] FOV = coverage_struct["FOV"][ii] area = coverage_struct["area"][ii] if params["tilesType"] == "galaxy": galaxies = coverage_struct["galaxies"][ii] if not telescope == coverage_struct["telescope"][ii]: continue if params["tilesType"] == "galaxy": overlap = np.setdiff1d(galaxies, cum_galaxies) if len(overlap) > 0: for galaxy in galaxies: if galaxy in cum_galaxies: continue if catalog_struct is None: continue if params["galaxy_grade"] == "Sloc": cum_prob = cum_prob + catalog_struct["Sloc"][galaxy] elif params["galaxy_grade"] == "S": cum_prob = cum_prob + catalog_struct["S"][galaxy] cum_galaxies = np.append(cum_galaxies, galaxies) cum_galaxies = np.unique(cum_galaxies).astype(int) cum_area = len(cum_galaxies) else: ipixs = np.append(ipixs, ipix) ipixs = np.unique(ipixs).astype(int) cum_prob = np.sum(map_struct["prob"][ipixs]) cum_area = len(ipixs) * map_struct["pixarea_deg2"] cum_probs.append(cum_prob) cum_areas.append(cum_area) tts.append(data[2] - event_mjd) ax2.plot(tts, cum_probs, color=color, linestyle='-', label=telescope) ax3.plot(tts, cum_areas, color=color, linestyle='--') ax2.set_xlabel('Time since event [days]') if params["tilesType"] == "galaxy": ax2.set_ylabel('Integrated Metric') else: ax2.set_ylabel('Integrated Probability') if params["tilesType"] == "galaxy": ax3.set_ylabel('Number of galaxies') else: ax3.set_ylabel('Sky area [sq. deg.]') ipixs = np.empty((0, 2)) cum_prob = 0.0 cum_area = 0.0 tts, cum_probs, cum_areas = [], [], [] if params["tilesType"] == "galaxy": cum_galaxies = [] for jj, ii in enumerate(idxs): data = coverage_struct["data"][ii, :] filt = coverage_struct["filters"][ii] ipix = coverage_struct["ipix"][ii] patch = coverage_struct["patch"][ii] FOV = coverage_struct["FOV"][ii] area = coverage_struct["area"][ii] if params["tilesType"] == "galaxy": galaxies = coverage_struct["galaxies"][ii] if params["tilesType"] == "galaxy": overlap = np.setdiff1d(galaxies, cum_galaxies) if len(overlap) > 0: for galaxy in galaxies: if galaxy in cum_galaxies: continue if catalog_struct is None: continue if params["galaxy_grade"] == "Sloc": cum_prob = cum_prob + catalog_struct["Sloc"][galaxy] elif params["galaxy_grade"] == "S": cum_prob = cum_prob + catalog_struct["S"][galaxy] cum_galaxies = np.append(cum_galaxies, galaxies) cum_galaxies = np.unique(cum_galaxies).astype(int) cum_area = len(cum_galaxies) else: ipixs = np.append(ipixs, ipix) ipixs = np.unique(ipixs).astype(int) cum_prob = np.sum(map_struct["prob"][ipixs]) cum_area = len(ipixs) * map_struct["pixarea_deg2"] tts.append(data[2] - event_mjd) cum_probs.append(cum_prob) cum_areas.append(cum_area) ax2.plot(tts, cum_probs, color='k', linestyle='-', label='All') ax3.plot(tts, cum_areas, color='k', linestyle='--') if len(params["telescopes"]) > 3: ax2.legend(loc=1, ncol=3, fontsize=10) ax2.set_ylim([0, 1]) ax3.set_ylim([0, 2000]) elif "IRIS" in params["telescopes"]: ax2.set_ylim([0, 0.3]) ax3.set_ylim([0, 1200]) ax2.legend(loc=1) elif "ZTF" in params["telescopes"]: ax2.set_ylim([0, 0.6]) ax3.set_ylim([0, 6000]) ax2.legend(loc=1) elif "PS1" in params["telescopes"]: ax2.set_ylim([0, 0.6]) ax3.set_ylim([0, 6000]) ax2.legend(loc=1) else: ax2.legend(loc=1) plt.show() plt.savefig(plotName, dpi=200) plt.close('all') filename = os.path.join(params["outputDir"], 'tiles_coverage_int.dat') fid = open(filename, 'w') for ii in range(len(tts)): fid.write('%.10f %.10e %.10f\n' % (tts[ii], cum_probs[ii], cum_areas[ii])) fid.close() print('Total Cumulative Probability, Area: %.5f, %.5f' % (cum_probs[-1], cum_areas[-1])) plotName = os.path.join(params["outputDir"], 'tiles_coverage_scaled.pdf') plt.figure() hp.mollview(map_struct["prob"], title='', unit=unit, cbar=cbar, cmap=cmap) add_edges() ax = plt.gca() for ii in range(len(coverage_struct["ipix"])): data = coverage_struct["data"][ii, :] filt = coverage_struct["filters"][ii] ipix = coverage_struct["ipix"][ii] patch = coverage_struct["patch"][ii] FOV = coverage_struct["FOV"][ii] if patch == []: continue #hp.visufunc.projplot(corners[:,0], corners[:,1], 'k', lonlat = True) patch_cpy = copy.copy(patch) patch_cpy.axes = None patch_cpy.figure = None patch_cpy.set_transform(ax.transData) current_alpha = patch_cpy.get_alpha() if current_alpha > 0.0: alpha = data[4] / max_time if alpha > 1: alpha = 1.0 patch_cpy.set_alpha(alpha) hp.projaxes.HpxMollweideAxes.add_patch(ax, patch_cpy) #tiles.plot() plt.show() plt.savefig(plotName, dpi=200) plt.close('all') if params["doMovie"]: idx = np.isfinite(coverage_struct["data"][:, 2]) mjd_min = np.min(coverage_struct["data"][idx, 2]) mjd_max = np.max(coverage_struct["data"][idx, 2]) mjd_N = 100 mjds = np.linspace(mjd_min, mjd_max, num=mjd_N) moviedir = os.path.join(params["outputDir"], 'movie') if not os.path.isdir(moviedir): os.mkdir(moviedir) #for jj in range(len(coverage_struct["ipix"])): # mjd = coverage_struct["data"][jj,3] for jj in range(len(mjds)): mjd = mjds[jj] plotName = os.path.join(moviedir, 'coverage-%04d.png' % jj) title = "Coverage Map: %.2f" % mjd plt.figure() hp.mollview(map_struct["prob"], title=title, unit=unit, cbar=cbar, cmap=cmap) add_edges() ax = plt.gca() idx = np.where(coverage_struct["data"][:, 2] <= mjd)[0] #for ii in range(jj): for ii in idx: data = coverage_struct["data"][ii, :] filt = coverage_struct["filters"][ii] ipix = coverage_struct["ipix"][ii] patch = coverage_struct["patch"][ii] FOV = coverage_struct["FOV"][ii] if patch == []: continue #hp.visufunc.projplot(corners[:,0], corners[:,1], 'k', lonlat = True) patch_cpy = copy.copy(patch) patch_cpy.axes = None patch_cpy.figure = None patch_cpy.set_transform(ax.transData) #alpha = data[4]/max_time #if alpha > 1: # alpha = 1.0 #patch_cpy.set_alpha(alpha) hp.projaxes.HpxMollweideAxes.add_patch(ax, patch_cpy) #tiles.plot() plt.show() plt.savefig(plotName, dpi=200) plt.close('all') moviefiles = os.path.join(moviedir, "coverage-%04d.png") filename = os.path.join(params["outputDir"], "coverage.mpg") ffmpeg_command = 'ffmpeg -an -y -r 20 -i %s -b:v %s %s' % ( moviefiles, '5000k', filename) os.system(ffmpeg_command) filename = os.path.join(params["outputDir"], "coverage.gif") ffmpeg_command = 'ffmpeg -an -y -r 20 -i %s -b:v %s %s' % ( moviefiles, '5000k', filename) os.system(ffmpeg_command) rm_command = "rm %s/*.png" % (moviedir) os.system(rm_command)
import numpy as np import matplotlib.pyplot as plt # convert test statistic to a p-value for a given point pVal_func = lambda TS, dec: -np.log10(0.5 * (chi2(1).sf(TS) + chi2(1).cdf(-TS))) if __name__=="__main__": # init the llh class llh = multi_init(3, 1000, 10000, energy=False, ncpu=4) print(llh) # iterator of all-sky scan with follow up scans of most interesting points for i, (scan, hotspot) in enumerate(llh.all_sky_scan(nside=32, pVal=pVal_func)): if i > 0: # break after first follow up break # plot results hp.mollview(scan["pVal"], min=0., cmap=plt.cm.afmhot) col = plt.gca()._get_lines.color_cycle for enum, llh_i in llh._sams.iteritems(): hp.projscatter(np.degrees(llh_i.exp["ra"]), np.degrees(np.arcsin(llh_i.exp["sinDec"])), lonlat=True, marker="x", color=col.next()) plt.show()
zred = zred[idy] mu_r = -1.0 + 2.*np.random.random(size = Nsize) phi_r = 2.0*np.pi*np.random.random(size = Nsize) theta_r = np.arccos(mu_r) pix = healpy.pixelfunc.ang2pix(2048, theta_r, phi_r) mask = (seln_func[pix] == 1) #Select only points within the seln_func theta_r = theta_r[mask] phi_r = phi_r[mask] zred_r = zred[np.random.permutation(phi_r.size) % zred.size] #Produce 'random' redshifts fig = plt.figure(1) healpy.mollview(seln_func,norm = 'hist', cmap = 'PRGn') fig.savefig(sel_fig) fig = plt.figure(2) healpy.mollview(seln_func, norm = 'hist', cmap = 'PRGn') healpy.projscatter(planck_theta, planck_phi, s = 1, lw = 0) fig.savefig(bcg_fig) fig = plt.figure(3) healpy.mollview(seln_func, norm = 'hist', cmap = 'PRGn') healpy.projscatter(theta_r, phi_r, s = 1, lw = 0) fig.savefig(dist_fig) # Now convert using astropy coordinates c = SkyCoord(l = phi_r, b = np.pi/2 - theta_r, frame = 'galactic', unit = 'radian') output = np.transpose([c.icrs.ra.deg,c.icrs.dec.deg,zred_r]) output = np.vstack((['RA','DEC','REDSHIFT'], output)) np.savetxt(out_path, output, fmt = '%s', delimiter = ',')
def creat_map(mkffile, ra, dec, time, outfile): mkfdata = fits.getdata(mkffile, 1) #Calculate Earth and CZTI Coords earth_coo, czti_z = get_angles(mkfdata, time, ra, dec, window=10) plotfile = PdfPages(outfile) #Calculate Earth RA DEC Dist earth_ra = earth_coo.fk5.ra.rad earth_dec = earth_coo.fk5.dec.rad earth_dist = earth_coo.fk5.distance.km #CZTI RA DEC czti_ra = czti_z.fk5.ra.rad czti_dec = czti_z.fk5.dec.rad #Load Bayestar File NSIDE = 512 no_pix = hp.nside2npix(NSIDE) prob = np.zeros(no_pix) # prob = hp.read_map(loc_map) # NSIDE = fits.open(args.loc_map)[1].header['NSIDE'] prob2 = np.copy(prob) prob3 = np.copy(prob) # # #ColorMap cmap = plt.cm.YlOrRd cmap.set_under("w") # # hp.mollview(prob, title='Complete Localisation Map', rot=(180, 0), cmap=cmap) # # hp.graticule() # plotfile.savefig() #Earth Occult czti_theta = np.pi / 2 - czti_dec czti_phi = czti_ra earth_theta = np.pi / 2 - earth_dec earth_phi = earth_ra earth_occult = np.arcsin(6378. / earth_dist) earth_vec = hp.ang2vec(earth_theta, earth_phi) earth = hp.query_disc(NSIDE, earth_vec, earth_occult) prob[earth] = np.nan not_occult = np.nansum(prob) # Add the GRB now grb_theta = np.pi / 2 - dec grb_phi = ra hp.mollview( prob, title= "Earth Occulted Localisation Map (Remaining Probability = {not_occult:2.3f})" .format(not_occult=not_occult), rot=(earth_theta, earth_phi), cmap=cmap) hp.graticule() hp.projscatter(czti_theta, czti_phi, color='r', marker='x') hp.projtext(czti_theta, czti_phi, 'CZTI') hp.projscatter(grb_theta, grb_phi, color='k', marker='o') hp.projtext(grb_theta, grb_phi, grbdir) hp.projscatter(earth_theta, earth_phi, color='g', marker='^') hp.projtext(earth_theta, earth_phi, 'Earth') plotfile.savefig() #Above Focal Plane back_vec = hp.ang2vec(np.pi - czti_theta, czti_phi) front = hp.query_disc(NSIDE, back_vec, np.pi / 2) prob2[front] = np.nan front_prob = np.nansum(prob2) hp.mollview( prob2, title= "Above the Focal Plane Localisation Map (Remaining Probability = {front_prob:2.3f})" .format(front_prob=front_prob), rot=(180, 0), cmap=cmap) hp.graticule() hp.projscatter(czti_theta, czti_phi, color='r', marker='x') hp.projtext(czti_theta, czti_phi, 'CZTI') hp.projscatter(grb_theta, grb_phi, color='k', marker='o') hp.projtext(grb_theta, grb_phi, grbdir) hp.projscatter(earth_theta, earth_phi, color='g', marker='^') hp.projtext(earth_theta, earth_phi, 'Earth') plotfile.savefig() #Earth Occult and Above Focal Plane prob2[earth] = np.nan final_prob = np.nansum(prob2) hp.mollview( prob2, title= "Earth Occult + Above Focal Plane (Remaining Probability = {final_prob:2.3f})" .format(final_prob=final_prob), rot=(180, 0), cmap=cmap) hp.graticule() hp.projscatter(czti_theta, czti_phi, color='r', marker='x') hp.projtext(czti_theta, czti_phi, 'CZTI') hp.projscatter(grb_theta, grb_phi, color='k', marker='o') hp.projtext(grb_theta, grb_phi, grbdir) hp.projscatter(earth_theta, earth_phi, color='g', marker='^') hp.projtext(earth_theta, earth_phi, 'Earth') plotfile.savefig() plotfile.close() return
def _plot_exampleSED(dictionary, center, nus_out, maskmaps, mapsarray = False, DeltaTheta = 0, DeltaPhi = 0, savefig = False, set_logscale = False, newnside = None, intensity = True, covmap = None): """ Plot an example of Figure 10 (map + SED ) in paper 1 =============== Parameters: dictionary: QUBIC dictionary center: center of the FOV for the map (maskmap) nus_out: frequencies where was reconstructed the map maskmap: a sky map. 'mask' prefix it's because is recommended to use masked maps (unseen values) in the unobserved region =============== Return: Figure with 2 subplots. At left a sky region (healpix projection), right subplot the SED. """ capsize=3 plt.rc('font', size=16) if newnside == None: nside = dictionary['nside'] else: nside = newnside pixG = [hp.ang2pix(nside, np.pi / 2 - np.deg2rad(center[1] + DeltaTheta ), np.deg2rad(center[0] + DeltaPhi) ), ] fig,ax = plt.subplots(nrows=1,ncols=2,figsize=(14,5),) ax = ax.ravel() IPIXG = pixG[0] color = ['g','g','k'] label = ['dust', 'synchrotron', 'dust+synchrotron'] marker = ['d', 's', 'o'] mask = covmap > 0.01 * np.max(covmap) mask = mask[0] print(mask.shape) if mapsarray: if intensity: for j, imap in enumerate(maskmaps): print(imap[:,IPIXG,0]) ax[1].plot(nus_out, imap[:,IPIXG,0], marker = marker[j], color=color[j], label = label[j], linestyle = "") ax[1].legend() ax[1].set_yscale("log") ax[0].cla() plt.axes(ax[0]) hp.gnomview(maskmaps[-1][-1,:,0], reso = 15,hold = True, title = ' ',unit = r'$\mu$K$_{CMB}$', notext =True, min = 0 , max = 0.23 * np.max(maskmaps[2][-1,:,0]), rot = center) elif not intensity: for j, imap in enumerate(maskmaps): #print(np.sqrt(imap[:,IPIXG,1]**2 + imap[:,IPIXG,2]**2)) ax[1].plot(nus_out, np.sqrt(imap[:,IPIXG,1]**2 + imap[:,IPIXG,2]**2), marker = marker[j], color=color[j], label = label[j], linestyle = "") ax[1].legend() ax[1].set_yscale("log") ax[0].cla() plt.axes(ax[0]) maximum = np.max(np.sqrt(maskmaps[-1][-1,mask,1]**2 + maskmaps[-1][-1,mask,2]**2)) print(maximum) visumap = np.sqrt(maskmaps[-1][-1,:,1]**2 + maskmaps[-1][-1,:,2]**2) visumap[~mask] = hp.UNSEEN hp.gnomview(visumap, reso = 15,hold = True, title = ' ', unit = r'$\mu$K$_{CMB}$', notext =True, min = -80 , max = 80, rot = center) else: ax[1].plot(nus_out, maskmaps[:,IPIXG,0], 'o-', color='r') ax[0].cla() plt.axes(ax[0]) hp.gnomview(maskmaps[-1,:,0], reso = 15,hold = True, title = ' ',unit = r'$\mu$K$_{CMB}$', notext =True, min = 0 , max = 0.23 * np.max(maskmaps[-1,:,0]), rot = center) hp.projscatter(hp.pix2ang(dictionary['nside'], IPIXG), marker = '*', color = 'r',s = 180) ylim = ax[1].get_ylim() xlim = ax[1].get_xlim() #ax[1].set_ylim(ylim[0], ylim[1]*2) if set_logscale: ax[1].set_xscale("log") ax[1].set_yscale("log") #ax[1].set_xticks([150, 220], ['150','220']) ax[1].xaxis.set_major_formatter(mtick.FormatStrFormatter('%.1f')) ax[1].xaxis.set_minor_formatter(mtick.ScalarFormatter()) ax[1].tick_params(axis = "both", which = "both", direction='in',width=1.3,) ax[1].grid(which="both") ax[1].set_ylabel(r'$I_\nu$ [$\mu$K$_{CMB}$]' if intensity else r'$P_\nu$ [$\mu$K$_{CMB}$]') ax[1].set_xlabel(r'$\nu$[GHz]') dpar = 10 dmer = 20 #Watch out, the names are wrong (change it) mer_coordsG = [ center[0] - dmer, center[0], center[0] + dmer] long_coordsG = [center[1] - 2*dpar, center[1] - dpar, center[1], center[1] + dpar, center[1] + 2 * dpar] #paralels for ilong in long_coordsG: plt.text(np.deg2rad(mer_coordsG[0] - 13), 1.1*np.deg2rad(ilong), r'{}$\degree$'.format(ilong)) #meridians for imer in mer_coordsG: if imer < 0: jmer = imer + 360 ip, dp = divmod(jmer/15,1) else: ip, dp = divmod(imer/15,1) if imer == 0: plt.text(-np.deg2rad(imer + 3), np.deg2rad(long_coordsG[-1] + 6), r'{}$\degree$'.format(int(ip) )) else: plt.text(-np.deg2rad(imer + 3), np.deg2rad(long_coordsG[-1] + 6), r'{}$\degree$'.format(imer)) hp.projtext(mer_coordsG[1] + 2, long_coordsG[0] - 6, '$l$', color = 'k', lonlat=True) hp.projtext(mer_coordsG[2] + 12.5, long_coordsG[2] - 1, '$b$', rotation = 90, color = 'k', lonlat=True) hp.graticule(dpar = dpar, dmer = dmer, alpha = 0.6, verbose = False) plt.tight_layout() if savefig: plt.savefig('SED-components.svg', format = 'svg', bbox_inches='tight') plt.savefig('SED-components.pdf', format = 'pdf', bbox_inches='tight') plt.savefig('SED-components', bbox_inches='tight') plt.show()
cut = np.logical_or(cut, labels == crab) ax.legend(handles[cut], labels[cut], loc=2) fig.tight_layout() # Plot the histogram of redshifts fig = plt.figure(2) ax = fig.add_subplot(111) nZ, Zbins, Zedges, Zwidths = zhist.GetHistogram() ax.bar(Zedges[:-1], nZ, width=Zwidths, fc="#aaaaff") #log=True, alpha=0.3) ax.set_xlabel("redshift") ax.set_ylabel("count") ax.set_title("1FHL Redshift Distribution") ax.grid(True) fig.tight_layout() # Plot the distribution of points on the sky title = r"GeV Sources within 50$^\circ$ of HAWC Zenith" if args.mapTitle: title = args.mapTitle fig = plt.figure(3, figsize=(9, 5)) hp.mollview(fig=3, coord="CG", title=title, rot=0) Decs = [90 * degree - d for d in Decs] fmax = np.max(iFlux) size = [100 * np.sqrt(1e14 * f) for f in iFlux] hp.projscatter(Decs, RAs, coord="CG", s=size, alpha=0.3) hp.graticule(coord="G", dpar=15, dmer=30) plt.show()
# In[23]: from astropy.io import fits hdr1 = fits.getheader(aligo_alert_data_file) # plot the banana map fig = plt.figure(2, figsize=(10, 10)) hp.mollview(aligo_banana, title='aLIGO alert Likelihood level', flip="astro", unit='$\Delta$', fig=2) fig.axes[1].texts[0].set_fontsize(8) #mean_zenith_ra = 15.*(alpha_observable_max.hour+alpha_observable_min.hour)/2. #zenith_dec = float(ephem.degrees(macon.lat*180./m.pi)) hp.projscatter(mean_zenith_ra, zenith_dec , lonlat=True, color="red") hp.projtext(mean_zenith_ra, zenith_dec, 'Macon Zenith\n (mean position\n over the night)', lonlat=True, color="red") for ra in range(0,360,60): for dec in range(-60,90,30): if not (ra == 300 and dec == -30): hp.projtext(ra,dec,'({}, {})'.format(ra,dec), lonlat=True, color='red') hp.graticule() plt.savefig(os.path.join(plots, 'allsky_likelihoodmap.png'), dpi=300) #plt.show() # In[28]:
else: print("# Choosing pixels from pixel number") # Where the sky pixel is in the reduce format (pixels seen array and not full map) pixQ_red = np.where(np.where(cov_ud[0] == True)[0] == pixQ_ud)[0][0] pixG_red = np.where(np.where(cov_ud[2] == True)[0] == pixG_ud)[0][0] print("# Done. Pixel in QUBIC FOV: {} \n \t Pixel in galactic center FOV: {}".format(pixQ_ud, pixG_ud)) print("# Reduce array. Pixel in QUBIC FOV: {} \n \t Pixel in galactic center FOV: {}".format(pixQ_red, pixG_red)) plt.figure(figsize = (10,4)) hp.gnomview(maps_ud[2,-1,:,0], reso = 15,#hold = True, notext = False, title = 'G patch ', sub = (121), max = 0.4*np.max(maps_ud[2,-1,:,0]), unit = r'$\mu$K', rot = centers[2]) hp.projscatter(hp.pix2ang(nside_new, pixG_ud), marker = '*', color = 'r', s = 200) hp.gnomview(maps_ud[1,-1,:,0], reso = 15, title = 'Q patch ', unit = r'$\mu$K', sub = (122), rot = centerQ) hp.projscatter(hp.pix2ang(nside_new, pixQ_ud), marker = '*', color = 'r', s = 200) hp.graticule(dpar = 10, dmer = 20, alpha = 0.6, verbose = False) plt.show() print("# Preparing for run MCMC ") _, nus150, nus_out150, _, _, _ = qubic.compute_freq(dictionaries[0]['filter_nu'] / 1e9, dictionaries[0]['nf_recon'], dictionaries[0]['filter_relative_bandwidth']) _, nus220, nus_out220, _, _, _ = qubic.compute_freq(dictionaries[1]['filter_nu'] / 1e9, dictionaries[1]['nf_recon'], dictionaries[1]['filter_relative_bandwidth']) nus_out = [nus_out150, nus_out220, nus_out150, nus_out220]
elif opts.coord.upper() == "CEL": coord = 'GC' if opts.proj.upper() == "MOL": #map = numpy.where( map < 20, healpy.UNSEEN, map) healpy.mollview(map,coord=coord,xsize=1000,min=20) elif opts.proj.upper() == "CAR": healpy.cartview(map,coord=coord,xsize=1000) else: raise Exception("...") healpy.graticule() if opts.targets: targets = numpy.genfromtxt(opts.targets,unpack=True,dtype=None) if not targets.shape: targets = targets.reshape(-1) coord = 'CG' # For RA/DEC input healpy.projscatter(targets['f1'],targets['f2'], lonlat=True,coord=coord,marker='o',c='w') fig = plt.gcf() # This is pretty hackish (but is how healpy does it...) for ax in fig.get_axes(): if isinstance(ax,healpy.projaxes.SphericalProjAxes): break for target in targets: text = TARGETS[target[0]][0] kwargs = TARGETS[target[0]][1] glon,glat = celToGal(target[1],target[2]) vec = healpy.rotator.dir2vec(glon,glat,lonlat=True) vec = (healpy.rotator.Rotator(rot=None,coord='G',eulertype='Y')).I(vec) x,y = ax.proj.vec2xy(vec,direct=False) ax.annotate(text,xy=(x,y),xycoords='data',**kwargs)
fluxplot = [(i * 100) / max(flux) for i in flux] #fluxplot=[(np.log10(i)*30)/np.log10(max(flux)) for i in flux] #Rot = 180 shifts the axis from the center to the edge #centered by default hp.mollview(title='Equatorial Map of SwiftBAT AGNs', cbar=False, rot=180, notext=True, cmap=None, coord='C') hp.graticule(coord='C', color='DimGrey') py.title(r"wrongdec - Equatorial", fontsize=25, fontweight='bold') #hp.projscatter(0,0,coord='G',lonlat=True) # This one used to test GC hp.projscatter(ra, dec, coord='C', lonlat=True, s=fluxplot) hp.projtext(185, 2, '180', lonlat=True, fontweight='bold') hp.projtext(95, 2, '90', lonlat=True, fontweight='bold') hp.projtext(275, 2, '270', lonlat=True, fontweight='bold') hp.projtext(8, 2, '0', lonlat=True, fontweight='bold') hp.projtext(359, 2, '360', lonlat=True, fontweight='bold') hp.projtext(193, -8, 'RA (deg)', lonlat=True, fontweight='bold') hp.projtext(350, 30, '30', lonlat=True, fontweight='bold') hp.projtext(340, 60, '60', lonlat=True, fontweight='bold') #hp.projtext(5, -5, 'Dec (deg)', lonlat=True) hp.projtext(358, -33.5, '-30', lonlat=True, fontweight='bold') hp.projtext(358, -63.5, '-60', lonlat=True, fontweight='bold') ra_gplane = np.arange(0., 361., 1.) dec_gplane = np.zeros(len(ra_gplane)) hp.projplot(ra_gplane,
def getObsWindow(date, obs_window): # =================================== # date is a string with the # Universal time, e.g. '2019/3/9 5:13' # obs_window is the radius(in degrees) # of the maximum deviation from the # Sun's antipodal point that HaloSat # is allowed to observe. # =================================== # Define the Sun object # ---------------------- sun = ephem.Sun() # Define the observer # ------------------- halosat = ephem.Observer() halosat.date = date # Get the location of the Sun # ---------------------------- sun.compute(halosat) hours = ephem.hours deg = ephem.degrees # Print out the antipodal point # ------------------------------- print('On the data', halosat.date) print('The RA of the Sun is', sun.ra) print('The Dec of the Sun is', sun.dec) print('So the HaloSat will observe') win_ra = hours(sun.ra + pi).norm win_dec = deg(sun.dec * (-1.)) print(' RA ', win_ra) print(' DEC', win_dec) # Read map of the galaxy for plotting the window # ---------------------------------------------- map = hp.read_map('ROSAT_Total_hp_filt.fits') cone_radius = obs_window / 57.2958 # convert to radians # Convert to Galactic coordinates # ------------------------------- ap = ephem.Equatorial(win_ra, win_dec, epoch='2000') sp = ephem.Equatorial(sun.ra, sun.dec, epoch='2000') g = ephem.Galactic(ap) s = ephem.Galactic(sp) print(g.lon, g.lat) vec = hp.ang2vec(g.lon * 57.4, g.lat * 57.2958, lonlat=True) local = hp.query_disc(512, vec, cone_radius) map[local] = nan hp.mollview(map, max=6000, title='Date: ' + str(halosat.date) + ', Window Center: [RA ' + str(win_ra) + ', DEC ' + str(win_dec) + ']') hp.projtext(g.lon * 57.2958 + 20, g.lat * 57.2958, 'Obs Window', lonlat=True, coord='G', fontsize=20) hp.projscatter(s.lon * 57.2958, s.lat * 57.2958, lonlat=True, s=55, coord='G', color='yellow') hp.projtext(s.lon * 57.2958 - 5, s.lat * 57.2958, 'Sun', lonlat=True, coord='G', fontsize=20)
def projected_density_plot( hitmap, figname = "skyplot.png", title = "", mincount = 35, maxcount = 40, NSIDE = 512, dpi = 150, xsize = 2000, inertia = [], walldir = [], filamentdir = [], cmap = cm_plusmin(under="w"), cbar = True, grid = False, scale = "log", ): if scale == "log": displayhitmap = np.log10(hitmap) else: displayhitmap = hitmap if mincount == "auto": mincount = min(displayhitmap) if maxcount == "auto": maxcount = max(displayhitmap) hp.mollview( displayhitmap, xsize = xsize, norm = 'lin', min = mincount, max = maxcount, title = title, cbar = cbar, cmap = cmap, ) if grid: hp.graticule() if len(filamentdir)!=0: filament = hp.vec2ang(filamentdir) anti_filament = hp.vec2ang(-filamentdir) hp.projscatter(filament, color='#ffff99') hp.projscatter(anti_filament, color='#ffff99') if len(walldir)!=0: wall = hp.vec2ang(walldir) anti_wall = hp.vec2ang(-walldir) hp.projscatter(wall, color='#ff99ff') hp.projscatter(anti_wall, color='#ff99ff') if len(inertia)!=0: inertia_axis_a = hp.vec2ang(inertia[0]) anti_inertia_axis_a = hp.vec2ang(-inertia[0]) inertia_axis_b = hp.vec2ang(inertia[1]) anti_inertia_axis_b = hp.vec2ang(-inertia[1]) inertia_axis_c = hp.vec2ang(inertia[2]) anti_inertia_axis_c = hp.vec2ang(-inertia[2]) hp.projscatter(inertia_axis_a, color='r') hp.projscatter(anti_inertia_axis_a, color='r') hp.projscatter(inertia_axis_b, color='y') hp.projscatter(anti_inertia_axis_b, color='y') hp.projscatter(inertia_axis_c, color='g') hp.projscatter(anti_inertia_axis_c, color='g') print "#saving fig as %s"%figname plt.savefig( figname, dpi = dpi, #bbox_inches='tight', ) plt.clf() return
def get_map(): # Get current time now = Time.now() T = datetime.utcnow() + timedelta(hours=0) T = Time(T, format="datetime") loc = astropy.coordinates.EarthLocation(lon=22.13303, lat=-31.58) ra = (T.sidereal_time("mean", longitude=22.13303)) / u.hourangle lon = ra * 15 - 360 rot = [(lon), -31.58] sid_time = T.sidereal_time("mean", longitude=22.13303) sidstr = sid_time.to_string() print(sidstr) moon = astropy.coordinates.get_moon(T, location=loc, ephemeris=None) sun = astropy.coordinates.get_sun(T) ssbodies = ["mercury", "venus", "mars", "jupiter", "saturn", "neptune", "uranus"] colors = ["grey", "pink", "red", "orange", "yellow", "blue", "blue", "blue"] pic = astropy.coordinates.SkyCoord( ra="05h19m49.7230919028", dec="-45d 46m 44s" ) # Pictor forn = astropy.coordinates.SkyCoord(ra="03h23m25.1s", dec="-37d 08m") cass = astropy.coordinates.SkyCoord(ra="23h 23m 24s", dec="+58d 48.9m") crab = astropy.coordinates.SkyCoord(ra="05h 34m 31s", dec="+22d 00m 52.2s") lmc = astropy.coordinates.SkyCoord(ra="05h 40m 05s", dec="-69d 45m 51s") smc = astropy.coordinates.SkyCoord(ra="00h 52m 44.8s", dec="-72d 49m 43s") cenA = astropy.coordinates.SkyCoord(ra="13h 25m 27.6s", dec="-43d 01m 09s") callibrator1 = astropy.coordinates.SkyCoord( ra=109.32351 * u.degree, dec=-25.0817 * u.degree ) callibrator2 = astropy.coordinates.SkyCoord( ra=30.05044 * u.degree, dec=-30.89106 * u.degree ) callibrator3 = astropy.coordinates.SkyCoord( ra=6.45484 * u.degree, dec=-26.0363 * u.degree ) source_list = [ [moon, "moon", "slategrey"], [sun, "sun", "y"], [pic, "pictor", "w"], [forn, "fornax", "w"], [cass, "Cass A", "w"], [crab, "Crab", "w"], [lmc, "LMC", "w"], [cenA, "Cen A", "w"], [smc, "SMC", "w"], [callibrator1, "J071717.6-250454", "r"], [callibrator2, "J020012.1-305327", "r"], [callibrator3, " J002549.1-260210", "r"], ] healpy.orthview( np.log10(mappy), title=sidstr, coord=["G", "C"], rot=rot, return_projected_map=True, min=0, max=2, half_sky=1, ) for item in source_list: if item[1] == "sun": name = item[1] healpy.projscatter( item[0].ra, item[0].dec, lonlat=True, s=1000, c=item[2], label=name ) healpy.projtext(item[0].ra, item[0].dec, lonlat=True, color="k", s=name) if item[1] == "moon": name = item[1] healpy.projscatter( item[0].ra, item[0].dec, lonlat=True, s=200, c=item[2], label=name ) healpy.projtext(item[0].ra, item[0].dec, lonlat=True, color="k", s=name) else: name = item[1] healpy.projscatter( item[0].ra, item[0].dec, lonlat=True, s=50, color=item[2], label=name ) healpy.projtext(item[0].ra, item[0].dec, lonlat=True, color="k", s=name) count = 0 for body in ssbodies: name = body body = astropy.coordinates.get_body(body, T) healpy.projscatter( body.ra, body.dec, lonlat=True, s=50, color=colors[count], label=name ) healpy.projtext(body.ra, body.dec, lonlat=True, color="k", s=name) count += 1
import healpy as hp import numpy as np import pylab as pl hp.mollview(title="Galactic map of Test Fields") # hp.graticule() x = [-37, 88, -137, -139, -136, -44] y = [27, -60, -1.4, -50, -77, -46] lab = ['TF0.1', 'TF0.2', 'TF0.3', 'TF0.4', 'TF0.5', 'TF0.6' ] hp.projscatter(x, y, lonlat=True, coord='G') hp.projtext(-37., 27., 'TF0.1', lonlat=True, coord='G') hp.projtext(88, -60, 'TF0.2', lonlat=True, coord='G') hp.projtext(-137, -1.4, 'TF0.3', lonlat=True, coord='G') hp.projtext(-139, -50, 'TF0.4', lonlat=True, coord='G') hp.projtext(-136, -77, 'TF0.5', lonlat=True, coord='G') hp.projtext(-44, -46, 'TF0.6', lonlat=True, coord='G') # equateur_lon = [-45.,45.] # equateur_lat = [-30.,30.] # hp.projplot(equateur_lon, equateur_lat, 'ro-', lonlat=True, coord='G') pl.show()