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)
