def plot_syst(name, fname, band, units=None, savename=None, scale=1): label = name if band is None: imap = 0 else: imap = ['g', 'r', 'i', 'z', 'y'].index(band) label += " " + band if units is not None: label += " [" + units + "]" _, mp = fm.read_flat_map(prefix + fname, i_map=imap) mp_mean = np.sum(msk_bin * msk * mp) / np.sum(msk_bin * msk) mp_plot = (msk_bin * (mp - mp_mean) + mp_mean) * scale mp_min = np.amin(mp_plot) mp_max = np.amax(mp_plot) if name == "Star count": mp_max = 4 mp_plot[msk_bin < 1] = mp_min - 1 fig = plt.figure() ax = fig.add_subplot(111, projection=fsk.wcs) im = ax.imshow(mp_plot.reshape([fsk.ny, fsk.nx]), vmin=mp_min, vmax=mp_max, origin='lower', interpolation='nearest') im.cmap.set_under('#FFFFFF') cbar = plt.colorbar(im, orientation='horizontal') cbar.ax.set_xlabel(label, fontsize=14) yticks = np.array([-6., -5., -4.]) ax.coords[1].set_ticks(yticks * u.deg) ax.coords[1].set_major_formatter('dd') ax.set_xlabel('R.A.', fontsize=14) ax.set_ylabel('Dec.', fontsize=14) if savename is not None: plt.savefig(savename, bbox_inches='tight')
def get_ndens_and_error(field_name): # This computes the number density and associated uncertainty # for all redshift bins for a given field. # Read mask prefix = "/global/cscratch1/sd/damonge/HSC_ceci/WIDE_" + field_name + "_sirius_i24p5_out/" prefix = "../data_replotting/" + field_name + "/" fsk, mskfrac = fm.read_flat_map(prefix + "masked_fraction.fits") msk_bin = np.zeros_like(mskfrac) msk_bin[mskfrac > 0.5] = 1 mskfrac *= msk_bin # Footprint area (in arcmin) area = np.sum(mskfrac) * fsk.dx * fsk.dy * 60**2 # Count number of galaxies in each redshift bin ngals = np.array([ np.sum(msk_bin * fm.read_flat_map(prefix + "ngal_maps.fits", i_map=2 * i)[1]) for i in range(4) ]) # Ell sampling for DFTs dlx = 2 * np.pi / np.radians(fsk.lx) dly = 2 * np.pi / np.radians(fsk.ly) ell_y = np.fft.fftfreq(fsk.ny, d=1. / (dly * fsk.ny)) ell_x = np.fft.fftfreq(fsk.nx, d=1. / (dlx * fsk.nx)) # |l| ell_mod = np.sqrt(ell_y[:, None]**2 + ell_x[None, :]**2) # Mask Fourier transform w2_fourier = np.absolute( np.fft.fft2(mskfrac.reshape([fsk.ny, fsk.nx])) / np.sum(mskfrac))**2 # Var(delta) = Int[dl^2 * |W(l)|^2 * C_l]/(2*pi)^2 sigma_delta = np.array([ np.sqrt(dlx * dly / (2 * np.pi)**2 * #dl_y * dl_x/2pi^2 np.sum(w2_fourier * 10.**lc(ell_mod))) # Sum[W^2 * C_ell] for lc in lclf ]) # Number densities ndens_amin = ngals / area # Poisson error sigma_ndens_sn = np.sqrt(ngals) / area # Total error sigma_ndens_cv = sigma_delta * ngals / area return area, ndens_amin, sigma_ndens_cv, sigma_ndens_sn
def check_sys(path_data, path_sys, mask_path, nbins=20): """ Routine to check the evolution of the mean density as a function of different potential sources of systematic biases/uncertanty on galaxy clustering Args: ----- path_data: Path to the catalog containing the clean data, it should contain RA and DEC. path_sys: Path to the flatmap of the contaminant(s) mask_path: Path to file containing the mask nbins: Number of bins in which to perform the analysis (20 by default) Outputs: -------- xsys: Values of the potential source of systematics in each bin mean: Mean galaxy density in each bin err: Error on the mean density in each bin """ fmi, s_map = fm.read_flat_map(path_sys, i_map=-1) fmm, mask = fm.read_flat_map(mask_path) binary_mask = mask>0 data = astropy.table.Table.read(path_data) data_map = np.bincount(fmi.pos2pix(data['ra'],data['dec']),minlength=fmi.npix) mean = [] err = [] bin_centers = [] for sys_map in s_map: aux_mean, bin_edges, _ = binned_statistic(sys_map[binary_mask], data_map[binary_mask]/mask[binary_mask], statistic='mean', bins=nbins) aux_std, bin_edges, _ = binned_statistic(sys_map[binary_mask], data_map[binary_mask]/mask[binary_mask], statistic='std', bins=nbins) aux_counts, bin_edges, _ = binned_statistic(sys_map[binary_mask], data_map[binary_mask]/mask[binary_mask], statistic='count', bins=nbins) mean.append(aux_mean) bin_centers.append(0.5*(bin_edges[1:]+bin_edges[:-1])) err.append(1.0*aux_std/np.sqrt(aux_counts)) return bin_centers, mean, err
def read_map_bands(fname, read_bands): if read_bands: i_map = -1 else: i_map = ['g', 'r', 'i', 'z', 'y'].index(o.band) fskb, temp = fm.read_flat_map(fname, i_map=i_map) fm.compare_infos(fsk, fskb) if i_map != -1: temp = [temp] return temp
def check_sys(data_hdu, path_sys, mask, nbins, **kwargs): """ Routine to check the evolution of the mean density as a function of different potential sources of systematic biases/uncertanty on galaxy clustering Args: ----- data_hdu: (HDU) HDU containing the data that we want to analyze. path_sys: (str) Path to the flatmap of the contaminant(s). mask: (flatmap) Mask of the region/survey to use. **kwargs: (dict) arguments to pass to `stats_on_sysmap` Outputs: -------- xsys_r: Values of the potential source of systematics in each bin rescaled by its mean xsys: Values of the potential source of systematics in each bin in the original units mean: Mean galaxy density in each bin err: Error on the mean density in each bin """ fmi, s_map = fm.read_flat_map(path_sys, i_map=-1) fmd, data_map = fm.read_flat_map(None, hdu=data_hdu) mean = [] err = [] bin_centers = [] bin_centers_resc = [] for sys_map in s_map: aux_centers, aux_centers_resc, aux_mean, aux_err = stats_on_sysmap( sys_map, mask, data_map, nbins, **kwargs) mean.append(aux_mean) bin_centers.append(aux_centers) bin_centers_resc.append(aux_centers_resc) err.append(aux_err) return np.array(bin_centers), np.array(bin_centers_resc), np.array( mean), np.array(err)
def __init__(self, hdu_list, i_bin, fsk, mask_binary, masked_fraction, contaminants=None): #Read numbers map self.fsk, nmap = fm.read_flat_map(None, hdu=hdu_list[2 * i_bin]) #Read N(z) self.nz_data = hdu_list[2 * i_bin + 1].data.copy() #Make sure other maps are compatible fm.compare_infos(self.fsk, fsk) if not self.fsk.is_map_compatible(mask_binary): raise ValueError("Mask size is incompatible") if not self.fsk.is_map_compatible(masked_fraction): raise ValueError("Mask size is incompatible") if contaminants is not None: for ic, c in enumerate(contaminants): if not self.fsk.is_map_compatible(c): raise ValueError( "%d-th contaminant template is incompatible" % ic) #Translate into delta map self.weight = masked_fraction * mask_binary goodpix = np.where(mask_binary > 0.1)[0] ndens = np.sum(nmap * mask_binary) / np.sum(self.weight) self.ndens_perad = ndens / (np.radians(self.fsk.dx) * np.radians(self.fsk.dy)) self.delta = np.zeros_like(self.weight) self.delta[goodpix] = nmap[goodpix] / (ndens * masked_fraction[goodpix]) - 1 #Reshape contaminants conts = None if contaminants is not None: conts = [[c.reshape([self.fsk.ny, self.fsk.nx])] for c in contaminants] #Form NaMaster field self.field = nmt.NmtFieldFlat( np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.weight.reshape([self.fsk.ny, self.fsk.nx]), [self.delta.reshape([self.fsk.ny, self.fsk.nx])], templates=conts)
def masks(): fname = os.path.join(outdir, 'mask-lss1.pdf') fmask = "./data/mask_lss_sph1.fits" mask_lss = hp.ud_grade(hp.read_map(fmask, verbose=False), nside_out=512) mask_lss[mask_lss == 0] = hp.UNSEEN hp.mollview(mask_lss, title="", cbar=False, coord=['G', 'C'], notext=True) plt.savefig(fname, dpi=DPI) plt.close() ############################################################################## ############################# Mask sph1 ###################################### ############################################################################## fname = os.path.join(outdir, 'mask-lss2.pdf') fmask = "./data/mask_lss_sph2.fits" mask_lss = hp.ud_grade(hp.read_map(fmask, verbose=False), nside_out=512) mask_lss[mask_lss == 0] = hp.UNSEEN hp.mollview(mask_lss, title="", coord=['G', 'C'], cbar=False, notext=True) plt.savefig(fname, dpi=DPI) plt.close() ############################################################################## ############################# Mask flat1 ###################################### ############################################################################## fname = os.path.join(outdir, 'mask-lss_flat1.pdf') fmask = "./data/mask_lss_flat.fits" f, ax = plt.subplots(figsize=(5, 2)) fmi, mask_hsc = fm.read_flat_map(fmask) mask_hsc[mask_hsc == 0] = hp.UNSEEN fmi.view_map(mask_hsc, ax=ax, addColorbar=False) plt.tight_layout() plt.savefig(fname, dpi=DPI, bbox_iches='tight', pad_inches=0) plt.close()
mask_thr=0.5 magran=[23.,27.] snr=10 mlim=24.5 fields=['WIDE_GAMA09H','WIDE_GAMA15H','WIDE_HECTOMAP','WIDE_VVDS', 'WIDE_WIDE12H','WIDE_AEGIS','WIDE_XMMLSS'] #fields=['WIDE_GAMA15H'] npix={} cls_raw={} cls_nd={} cls_ns={} cls_nds={} for field in fields : print(field) #Create depth-based mask fsk,mp_depth=fm.read_flat_map(predir+field+'/'+field+"_%ds_depth_mean_fluxerr.fits"%snr,2) mp_depth[np.isnan(mp_depth)]=0; mp_depth[mp_depth>40]=0 msk_depth=np.zeros_like(mp_depth); msk_depth[mp_depth>=mlim]=1 #Read masked fraction fskb,mskfrac=fm.read_flat_map(predir+field+'/'+field+"_MaskedFraction.fits") if fsk.get_dims()!=fskb.get_dims() : raise ValueError("Inconsistent fskys") #Create BO-based mask msk_bo=np.zeros_like(mskfrac); msk_bo[mskfrac>mask_thr]=1 msk_t=msk_bo*msk_depth goodpix=np.where(msk_t>0.1)[0] #Total weight map weight=mskfrac*msk_t
band = ['g', 'r', 'i', 'z', 'y'] cont_maps = ['oc_airmass','oc_ccdtemp','oc_ellipt','oc_exptime','oc_nvisit', \ 'oc_seeing', 'oc_sigma_sky', 'oc_skylevel','syst_dust','syst_nstar_i24.50'] xlabels= ['Airmass', r'CCD Temperature [$^{\circ}$C]', 'PSF Ellipticity', \ 'Exposure Time [s]', 'Number of visits', 'Seeing [pixels]', 'Sky noise [ADU]', \ 'Sky level [ADU]', 'Extinction', 'Stars per pixel'] data_hdus = fits.open(o.fname_maps) if len(data_hdus) % 2 != 0: raise ValueError("Input file should have two HDUs per map") nbins = len(data_hdus) // 2 os.system('mkdir -p ' + o.prefix_out) print("Reading mask") #Create depth-based mask fsk, mp_depth = fm.read_flat_map(o.prefix_in + "_10s_depth_mean_fluxerr.fits", 2) mp_depth[np.isnan(mp_depth)] = 0 mp_depth[mp_depth > 40] = 0 msk_depth = np.zeros_like(mp_depth) msk_depth[mp_depth >= o.depth_cut] = 1 #Read masked fraction fskb, mskfrac = fm.read_flat_map(o.prefix_in + '_MaskedFraction.fits', i_map=0) fm.compare_infos(fsk, fskb) #Create BO-based mask msk_bo = np.zeros_like(mskfrac) msk_bo[mskfrac > o.mask_thr] = 1 msk_t = msk_bo * msk_depth * mskfrac for ibin in range(nbins):
parser.add_option( '--histogram-nbins', dest='nbin_hist', default=40, type=int, help= 'Number of bins for each systematic (used to compute mean and median maps)' ) #### # Read options (o, args) = parser.parse_args() print("Reading map") try: fsk, mp = fm.read_flat_map(o.fname_map_sample) except: raise ValueError("Can't read sample map from " + o.fname_map_sample) print("Reading metadata") try: data = fits.open(o.fname_frames)[1].data except: raise ValueError("Can't read metadata from " + o.fname_frames) print("Computing frame coords") ix_ll, iy_ll, in_ll = fsk.pos2pix2d(data['llcra'], data['llcdecl']) ix_ul, iy_ul, in_ul = fsk.pos2pix2d(data['ulcra'], data['ulcdecl']) ix_ur, iy_ur, in_ur = fsk.pos2pix2d(data['urcra'], data['urcdecl']) ix_lr, iy_lr, in_lr = fsk.pos2pix2d(data['lrcra'], data['lrcdecl']) #Keep only frames that fit inside the field
def dig_hole(x, y, r): rad = (np.sqrt((xarr - x)**2 + (yarr - y)**2)).flatten() return np.where(rad < r)[0] nholes = 50 for i in np.arange(nholes): r = np.random.rand(3) mask[dig_hole(r[0] * mi.lx, r[1] * mi.ly, (0.005 + 0.02 * r[2]) * np.sqrt(mi.lx * mi.ly))] = 0. mask_raw = mask.copy() if aposize > 0: mask = nmt.mask_apodization_flat(mask_raw.reshape([mi.ny, mi.nx]), mi.lx * DTOR, mi.ly * DTOR, aposize) mi.write_flat_map(fname_mask, mask.flatten()) mi, mask = fm.read_flat_map(fname_mask + '.npz') mi = fm.FlatMapInfo([212.5, 222.], [-2., 2.], nx=792, ny=336) mask = mask.reshape([mi.ny, mi.nx]) if plotres: mi.view_map(mask.flatten(), addColorbar=False, colorMax=1, colorMin=0) if w_cont: if not os.path.isfile(prefix + "_contaminants.npz"): fgt, fgq, fgu = nmt.synfast_flat(int(mi.nx), int(mi.ny), mi.lx * DTOR, mi.ly * DTOR, [clttfg, cleefg, clbbfg, cltefg], pol=True) mi.write_flat_map( prefix + "_contaminants",
if o.low_noise_ee_bb: nlee *= 1e-2 nlbb *= 1e-2 if o.plot_stuff : plt.figure() plt.plot(l,cltt,'r-',label='TT') plt.plot(l,clee,'b-',label='EE') plt.plot(l,clbb,'g-',label='BB') plt.plot(l,clte,'y-',label='TE') plt.loglog() plt.legend() #Read mask fmi,mask_hsc=fm.read_flat_map("data/mask_lss_flat.fits") if o.plot_stuff : fmi.view_map(mask_hsc) #Set up binning scheme ell_min=max(2*np.pi/fmi.lx_rad,2*np.pi/fmi.ly_rad) ell_max=min(fmi.nx*np.pi/fmi.lx_rad,fmi.ny*np.pi/fmi.ly_rad) d_ell=2*ell_min n_ell=int((ell_max-ell_min)/d_ell)-1 l_bpw=np.zeros([2,n_ell]) l_bpw[0,:]=ell_min+np.arange(n_ell)*d_ell l_bpw[1,:]=l_bpw[0,:]+d_ell b=nmt.NmtBinFlat(l_bpw[0,:],l_bpw[1,:]) #Read/Generate Large Scale contaminant fields templates_ls = []
ll = np.arange(len(data[0]) + 2) + 0. fac = 2 * np.pi / (ll[2:] * (ll[2:] + 1.)) cl_tt = np.zeros_like(ll) cl_tt[2:] = data[1, :] * fac cl_ee = np.zeros_like(ll) cl_ee[2:] = data[2, :] * fac cl_bb = np.zeros_like(ll) cl_bb[2:] = data[3, :] * fac cl_te = np.zeros_like(ll) cl_te[2:] = data[4, :] * fac return ll, cl_tt, cl_ee, cl_bb, cl_te l, cltt, clee, clbb, clte = read_cl_camb("cls_cmb.txt") fmi, msk = fm.read_flat_map("mask_cmb_flat.fits") #Generate random homogeneous realization with the right power spectrum. ccee = 2E-5 * (100. / (l + 0.1))**2.5 ccee[:10] = ccee[10] ccbb = 9E-6 * (100. / (l + 0.1))**2.3 ccbb[:10] = ccbb[10] czero = np.zeros_like(ccee) ratio = np.sqrt(0.2 * np.mean(clbb[500:600]) / np.mean(ccbb[500:600])) t, q, u = fmi.synfast(l, np.array([czero, ccee, ccbb, czero])) q *= ratio u *= ratio fmi.write_flat_map("cont_cmb_flat.fits", np.array([q, u])) if o.plot_stuff:
msk *= np.logical_not(cat['iflags_pixel_bright_object_any']) cat = cat[msk] if o.use_pdf: # Read in pdfs and bins pdf_file = o.prefix_in + '_pdfs_' + o.pz_type + '.fits' pdfs = fits.open(pdf_file)[1].data['pdf'] bins = fits.open(pdf_file)[2].data['bins'] pdfs = pdfs[msk] if o.use_cosmos: # Read in weights and bins weights_file = fits.open(o.cosmos_weights_file)[1].data #Read map information fsk, mpdum = fm.read_flat_map(o.map_sample, 0) #Read bins zi_arr, zf_arr = np.loadtxt(o.fname_bins, unpack=True, ndmin=2) nbins = len(zi_arr) #Iterate through bins maps = [] nzs = [] for zi, zf in zip(zi_arr, zf_arr): msk = (cat[column_mark] <= zf) & (cat[column_mark] > zi) subcat = cat[msk] if o.use_pdf: binpdfs = pdfs[ msk] # The pdfs which have a redshift in the correct bin bz = np.linspace(0, o.nz_bin_max, o.nz_bin_num + 1)
if o.plot_stuff : plt.figure() plt.plot(l,cltt,'r-',label='TT') plt.plot(l,clee,'b-',label='EE') plt.plot(l,clbb,'g-',label='BB') plt.plot(l,clte,'y-',label='TE') plt.loglog() plt.legend() #Read mask fmasks = ["data/mask_lss_flat.fits", "data/mask_lss_flat_2.fits"] fmi_ar, mask_hsc_ar = [], [] for fmask in fmasks: fmi, mask_hsc=fm.read_flat_map(fmask) fmi_ar.append(fmi) mask_hsc_ar.append(mask_hsc) if o.plot_stuff : fmi_ar[0].view_map(mask_hsc_ar[0]) fmi_ar[1].view_map(mask_hsc_ar[1]) #Set up binning scheme. Both masks have same nx, ny, ... ell_min=max(2*np.pi/fmi.lx_rad,2*np.pi/fmi.ly_rad) ell_max=min(fmi.nx*np.pi/fmi.lx_rad,fmi.ny*np.pi/fmi.ly_rad) d_ell=2*ell_min n_ell=int((ell_max-ell_min)/d_ell)-1 l_bpw=np.zeros([2,n_ell]) l_bpw[0,:]=ell_min+np.arange(n_ell)*d_ell l_bpw[1,:]=l_bpw[0,:]+d_ell
def tickfs(ax, x=True, y=True): if x: for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(12) if y: for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(12) if (o.whichfig == 3) or (o.whichfig == -1): #Plotting flat-sky LSS maps l, cltt, clee, clbb, clte, nltt, nlee, nlbb, nlte = np.loadtxt( "cls_lss.txt", unpack=True) fmi, msk_f = fm.read_flat_map("mask_lss_flat.fits") mpt_f, mpq_f, mpu_f = fmi.synfast(l, np.array([cltt, clee, clbb, clte])) fdum, [cwp_q_f, cwp_u_f] = fm.read_flat_map("cont_wl_psf_flat.fits", i_map=-1) fdum, [cws_q_f, cws_u_f] = fm.read_flat_map("cont_wl_ss_flat.fits", i_map=-1) fdum, cld_f = fm.read_flat_map("cont_lss_dust_flat.fits") fdum, cls_f = fm.read_flat_map("cont_lss_star_flat.fits") plt.figure(figsize=(12, 9.5)) tonull = np.where(msk_f == 0) fs_or = matplotlib.rcParams['font.size'] ax = plt.subplot(421, projection=fmi.wcs) mpp = msk_f.copy() # mpp[tonull]=np.nan fmi.view_map(mpp, ax=ax, addColorbar=False, title='Mask') ax = plt.subplot(422, projection=fmi.wcs)
import flatmaps as fm import numpy as np import matplotlib.pyplot as plt from astropy import units as u prefix = "/global/cscratch1/sd/damonge/HSC_ceci/WIDE_XMMLSS_sirius_i24p5_out/" fsk, msk = fm.read_flat_map(prefix + "masked_fraction.fits") msk_bin = np.zeros_like(msk) msk_bin[msk > 0.] = 1 def plot_syst(name, fname, band, units=None, savename=None, scale=1): label = name if band is None: imap = 0 else: imap = ['g', 'r', 'i', 'z', 'y'].index(band) label += " " + band if units is not None: label += " [" + units + "]" _, mp = fm.read_flat_map(prefix + fname, i_map=imap) mp_mean = np.sum(msk_bin * msk * mp) / np.sum(msk_bin * msk) mp_plot = (msk_bin * (mp - mp_mean) + mp_mean) * scale mp_min = np.amin(mp_plot) mp_max = np.amax(mp_plot) if name == "Star count": mp_max = 4 mp_plot[msk_bin < 1] = mp_min - 1 fig = plt.figure() ax = fig.add_subplot(111, projection=fsk.wcs)
raise ValueError( 'Something is not right. Have more than one folder for %s: %s' % (field, folder)) ########################################################################################## # read the mask fraction file for i, maskedfrac_file in enumerate([ f for f in os.listdir('%s/%s' % (datapath, folder)) if f.__contains__('MaskedFraction') ]): if i > 0: raise ValueError( 'Something is wrong. Have more than one MaskedFraction file in %s/%s' % (datapath, folder)) print('\nReading in %s' % maskedfrac_file) fskb, mskfrac = fm.read_flat_map( '%s/%s/%s' % (datapath, folder, maskedfrac_file)) patch_area = np.sum(mskfrac) * np.radians(fskb.dx) * np.radians( fskb.dy) # in Sr sns, all_bins = {}, {} # ------------------------------------------------------------------------------------------------------------------------ for alg in PZalg: print('\n######### Working with with %s' % alg) filename = '%s_pdfs_%s.fits' % (field.upper(), alg) print('Reading in %s' % filename) hdul = fits.open('%s/%s' % (pdfs_path, filename)) # read in the relevant arrays pdfs = hdul[1].data['pdf'] ids = hdul[1].data['object_id'] bins = hdul[2].data['bins']
def get_pointing_map(self, name): fsk, mp = fm.read_flat_map(self.prefix_data + name + '.fits') return fsk, mp
# drop the columns now. irrelevant. data = data.drop(isNulls, axis=1) print 'Dropped %s columns.' % len(isNulls) noClassInd = np.where(np.isnan(data['iclassification_extendedness']))[0] print 'Dropped %s entries.' % len(noClassInd) data = data.drop(noClassInd, axis=0) print 'Final size: ', np.shape(data) before = len(data) data = data.dropna(axis=0) print 'Dropped %s rows' % (before - len(data.keys())) print 'Final size: ', np.shape(data) #Make a map from galaxy positions print "Pixel indices" ipix = mi.pos2pix(data['ra'], data['dec']) print "Binning" #Bin positions into pixels mp = np.bincount(ipix, minlength=mi.get_size()) print "Writing map" mi.write_flat_map("map_test", mp) print "Reading map" mi2, mp2 = fm.read_flat_map("map_test.npz") print "Plotting" #Plot resulting map mi.view_map(mp) mi2.view_map(mp2) plt.show()
import sys import flatmaps as fm import healpy as hp import numpy as np fname_batch = sys.argv[1] batch = open(fname_batch, 'r') lines = batch.readlines() for line in lines: fname_in, fname_out = line.split(' ') fname_out = fname_out.rstrip() print(fname_in, flush=True) fsk, mp = fm.read_flat_map(fname_in) npix = fsk.nx * fsk.ny ipix = np.arange(npix) ra, dec = fsk.pix2pos(ipix) nside = 2048 npix_hp = hp.nside2npix(nside) ipix_hp = hp.ang2pix(nside, ra, dec, lonlat=True) i_good = ~np.isnan(mp) nc_good = np.bincount(ipix_hp[i_good], minlength=npix_hp) nc_all = np.bincount(ipix_hp, minlength=npix_hp) vsum = np.bincount(ipix_hp[i_good], minlength=npix_hp, weights=mp[i_good]) v2sum = np.bincount(ipix_hp[i_good], minlength=npix_hp, weights=mp[i_good]**2) hp.write_map(fname_out, [vsum, v2sum, nc_good, nc_all], column_names=['v_sum', 'v2_sum', 'n_good', 'n_all'])
from astropy.io import fits predir = "/global/cscratch1/sd/damonge/HSC/HSC_processed/" mask_thr = 0.7 magran = [23., 27.] snr = 10 mlim = 24.5 fields = [ 'WIDE_GAMA09H', 'WIDE_GAMA15H', 'WIDE_HECTOMAP', 'WIDE_VVDS', 'WIDE_WIDE12H', 'WIDE_AEGIS', 'WIDE_XMMLSS' ] depth_hists = {} npixs = {} ngals = {} for field in fields: fsk, mp_depth = fm.read_flat_map( predir + field + '/' + field + "_%ds_depth_mean_fluxerr.npz" % snr, 2) mp_depth[np.isnan(mp_depth)] = 0 mp_depth[mp_depth > 40] = 0 fskb, masked = fm.read_flat_map(predir + field + '/' + field + "_MaskedFraction.npz") cat = fits.open(predir + field + "/" + field + '_Catalog_i%.2lf.fits' % mlim)[1].data mskob = ~(cat['iflags_pixel_bright_object_center'] * cat['iflags_pixel_bright_object_any']) cat = cat[mskob] if fsk.get_dims() != fskb.get_dims(): raise ValueError("Inconsistent fskys") goodpix = np.where(masked > mask_thr)[0] mask = np.zeros_like(masked) mask[goodpix] = 1 fsk.view_map(mp_depth * mask,
'correlations (11,12,...,1N,22,23,...,NN)') parser.add_option( '--covariance-coupling-file', dest='covar_coup', default='NONE', type=str, help='If computing the theory covariance, pass a file name where the ' + 'coupling coefficients will be stored. If NONE, they won\'t be saved') #### # Read options (o, args) = parser.parse_args() print("Reading mask") #Create depth-based mask fsk, mp_depth = fm.read_flat_map(o.prefix_in + "_10s_depth_mean_fluxerr.fits", 2) mp_depth[np.isnan(mp_depth)] = 0 mp_depth[mp_depth > 40] = 0 msk_depth = np.zeros_like(mp_depth) msk_depth[mp_depth >= o.depth_cut] = 1 #Read masked fraction fskb, mskfrac = fm.read_flat_map(o.prefix_in + '_MaskedFraction.fits', i_map=0) fm.compare_infos(fsk, fskb) #Create BO-based mask msk_bo = np.zeros_like(mskfrac) msk_bo[mskfrac > o.mask_thr] = 1 msk_t = msk_bo * msk_depth #Area
matplotlib.rcParams['xtick.minor.width'] = 1.6 matplotlib.rcParams['xtick.major.width'] = 1.6 matplotlib.rcParams['ytick.major.size'] = 7 matplotlib.rcParams['ytick.minor.size'] = 4 matplotlib.rcParams['ytick.major.pad'] = 6 matplotlib.rcParams['ytick.minor.pad'] = 6 matplotlib.rcParams['ytick.labelsize'] = 32 matplotlib.rcParams['ytick.minor.width'] = 1.6 matplotlib.rcParams['ytick.major.width'] = 1.6 times = np.array([ 5.705970149253732, 6.402985074626866, 7.629850746268656, 8.938805970149254 ]) chis = 3261633.44 * np.array([1462., 1694., 2144., 2704.]) / 0.67 # lightyears dchis = chis * np.radians(1.) * 1E-6 _, mp1 = fm.read_flat_map("../data_replotting/XMMLSS/ngal_maps.fits", i_map=0) _, mp2 = fm.read_flat_map("../data_replotting/XMMLSS/ngal_maps.fits", i_map=2) _, mp3 = fm.read_flat_map("../data_replotting/XMMLSS/ngal_maps.fits", i_map=4) _, mp4 = fm.read_flat_map("../data_replotting/XMMLSS/ngal_maps.fits", i_map=6) fsk, msk = fm.read_flat_map("../data_replotting/XMMLSS/masked_fraction.fits") msk[msk < 0.001] = 0 msk[msk >= 0.001] = 1 cmap = cm.jet cmap.set_bad(color='#DDDDDD') from matplotlib.patches import Rectangle from scipy.ndimage import gaussian_filter fig = plt.figure(figsize=(20, 4 * fsk.ny * 20. / fsk.nx)) plt.subplots_adjust(hspace=0)
import flatmaps as fm import numpy as np import matplotlib.pyplot as plt from matplotlib import cm from astropy import units as u yticks={'GAMA09H':[0.,1.,2.], 'GAMA15H':[-1., 0., 1.], 'HECTOMAP':[43., 44.], 'VVDS':[0., 1., 2.], 'WIDE12H':[-1., 0., 1.], 'XMMLSS':[-6., -5., -4.] } for field in ['GAMA09H','GAMA15H','HECTOMAP','VVDS','WIDE12H','XMMLSS']: fsk,msk=fm.read_flat_map("/global/cscratch1/sd/damonge/HSC_ceci/WIDE_"+field+"_sirius_i24p5_out/masked_fraction.fits") fig=plt.figure() ax=fig.add_subplot(111,projection=fsk.wcs) ax.set_title(field,fontsize=14) im=ax.imshow(msk.reshape([fsk.ny,fsk.nx]),vmin=0,vmax=1, origin='lower', interpolation='nearest', cmap=cm.gray) ax.set_xlabel('R.A.', fontsize=14) ax.set_ylabel('Dec.', fontsize=14) ax.coords[1].set_ticks(np.array(yticks[field]) * u.deg) ax.coords[1].set_major_formatter('dd') plt.savefig("../doc/Paper/figures/mask_"+field+".pdf",bbox_inches='tight') plt.show()
import flatmaps as fm import numpy as np import matplotlib.pyplot as plt from astropy import units as u prefix = "/global/cscratch1/sd/damonge/HSC_ceci/WIDE_" field = "VVDS" fsk, msk1 = fm.read_flat_map(prefix + field + "_sirius_i24p5_out/masked_fraction.fits") msk1[msk1 < 0.5] = 0 msk1[msk1 >= 0.5] = 1. _, msk2 = fm.read_flat_map( prefix + field + "_sirius_i24p5_out/" + "CovAna_NoiAna_MskSiriusSyst_ClFit_Dpj0_DpjBands1/mask_syst.fits") _, msk3 = fm.read_flat_map(prefix + field + "_arcturus_i24p5_out/masked_fraction.fits") msk3[msk3 < 0.5] = 0 msk3[msk3 >= 0.5] = 1. fig = plt.figure(figsize=(8, 8)) ax = fig.add_subplot(211, projection=fsk.wcs) ax.set_title("Sirius mask", fontsize=14) im = ax.imshow((msk1 + msk2).reshape([fsk.ny, fsk.nx]), vmin=0, vmax=2, origin='lower', interpolation='nearest') yticks = np.array([0., 1., 2.]) ax.coords[1].set_ticks(yticks * u.deg) ax.coords[1].set_major_formatter('dd') ax.set_xlabel('R.A.', fontsize=14)
def opt_callback(option, opt, value, parser): setattr(parser.values, option.dest, value.split(',')) parser = OptionParser() parser.add_option('--plot', dest='plot_stuff', default=False, action='store_true', help='Set if you want to produce plots') (o, args) = parser.parse_args() l, cltt, clee, clbb, clte, nltt, nlee, nlbb, nlte = np.loadtxt("cls_lss.txt", unpack=True) fmi, msk = fm.read_flat_map("mask_lss_flat.fits") mpt, mpq, mpu = fmi.synfast(l, np.array([cltt, clee, clbb, clte])) #Star contaminant (basically something that affects mostly small scales) if not os.path.isfile("cont_lss_star_flat.fits"): loff = 500. ltouch = 5000 frac = 0.2 plaw = 1.2 clstar = frac * cltt[ltouch] * ((ltouch + loff) / (l + loff))**plaw clstar[:2] = 0 mp_star = fmi.synfast(l, clstar) if o.plot_stuff: ls, cl_c = fmi.anafast(mp_star)