def init_geometry(ishape,iwcs):
modlmap = enmap.modlmap(ishape,iwcs)
bin_edges = np.arange(args.kellmin,args.kellmax,args.dell)
binner = stats.bin2D(modlmap,bin_edges)
if args.beam<1e-5:
kbeam = None
else:
kbeam = maps.gauss_beam(modlmap,args.beam)
lmax = modlmap.max()
ells = np.arange(2,lmax,1)
wnoise_TT = ells*0.+(args.noise*(np.pi/180./60.))**2.
wnoise_PP = 2.*wnoise_TT
nT = modlmap*0.+(args.noise*(np.pi/180./60.))**2.
nP = 2.*nT
ncomp = 3 if pol else 1
ps = np.zeros((ncomp,ncomp,ells.size))
ps[0,0] = wnoise_TT
if pol:
ps[1,1] = wnoise_PP
ps[2,2] = wnoise_PP
oshape = (3,)+ishape if pol else ishape
if not(args.flat) and args.noise_pad>1.e-5:
# Pad noise sim geometry
pad_width_deg = args.noise_pad
pad_width = pad_width_deg * np.pi/180.
res = maps.resolution(oshape[-2:],iwcs)
pad_pixels = int(pad_width/res)
template = enmap.zeros(oshape,iwcs)
btemplate = enmap.pad(template,pad_pixels)
bshape,bwcs = btemplate.shape,btemplate.wcs
del template
del btemplate
ngen = maps.MapGen(bshape,bwcs,ps)
else:
ngen = maps.MapGen(oshape,iwcs,ps)
tmask = maps.mask_kspace(ishape,iwcs,lmin=args.tellmin,lmax=args.tellmax)
pmask = maps.mask_kspace(ishape,iwcs,lmin=args.pellmin,lmax=args.pellmax)
kmask = maps.mask_kspace(ishape,iwcs,lmin=args.kellmin,lmax=args.kellmax)
qest = lensing.qest(ishape,iwcs,theory,noise2d=nT,beam2d=kbeam,kmask=tmask,noise2d_P=nP,kmask_P=pmask,kmask_K=kmask,pol=pol,grad_cut=None,unlensed_equals_lensed=True)
taper,w2 = maps.get_taper_deg(ishape,iwcs,taper_width_degrees = args.taper_width,pad_width_degrees = args.pad_width)
fc = maps.FourierCalc(oshape,iwcs,iau=args.iau)
purifier = maps.Purify(ishape,iwcs,taper) if args.purify else None
return qest,ngen,kbeam,binner,taper,fc,purifier
def process(kouts, name="default", ellmax=None, y=False, y_ellmin=400):
ellmax = lmax if ellmax is None else ellmax
ksilc = enmap.zeros((Ny, Nx), wcs, dtype=np.complex128).reshape(-1)
ksilc[modlmap.reshape(-1) < lmax] = np.nan_to_num(kouts.copy())
ksilc = enmap.enmap(ksilc.reshape((Ny, Nx)), wcs)
ksilc[modlmap > ellmax] = 0
if y: ksilc[modlmap < y_ellmin] = 0
msilc = np.nan_to_num(
fft.ifft(ksilc, axes=[-2, -1], normalize=True).real * bmask)
enmap.write_map(proot + "outmap_%s.fits" % name, enmap.enmap(msilc, wcs))
p2d = fc.f2power(ksilc, ksilc)
bin_edges = np.arange(100, 3000, 40)
binner = stats.bin2D(modlmap, bin_edges)
cents, p1d = binner.bin(p2d)
try:
# io.plot_img(np.log10(np.fft.fftshift(p2d)),proot+"ksilc_%s.png" % name,aspect='auto')
# io.plot_img(msilc,proot+"msilc_%s.png" % name)
# io.plot_img(msilc,proot+"lmsilc_%s.png" % name,lim=300)
tmask = maps.mask_kspace(shape,
wcs,
lmin=300,
lmax=5000 if not (y) else 1500)
fmap = maps.filter_map(msilc, tmask) * bmask
io.plot_img(fmap, proot + "hmsilc_%s.png" % name, high_res=True)
except:
pass
return cents, p1d
def lens(ulensed,convergence):
posmap = ulensed.posmap()
kmask = maps.mask_kspace(ulensed.shape,ulensed.wcs,lmin=10,lmax=8000)
phi,_ = lensing.kappa_to_phi(enmap.enmap(maps.filter_map(enmap.enmap(convergence,wcs),kmask),wcs),ulensed.modlmap(),return_fphi=True)
grad_phi = enmap.grad(phi)
pos = posmap + grad_phi
alpha_pix = ulensed.sky2pix(pos, safe=False)
lensed = enlensing.displace_map(ulensed, alpha_pix, order=5)
return lensed
"WORK"] + "/data/depot/tilec/v1.2.0_20200324/map_v1.2.0_%s_%s/tilec_single_tile_%s_cmb_map_v1.2.0_%s.fits" % (
cversion, region, region, cversion)
# CMB deproj-tSZ maps
bfile3 = os.environ[
"WORK"] + "/data/depot/tilec/v1.2.0_20200324/map_v1.2.0_%s_%s/tilec_single_tile_%s_cmb_deprojects_comptony_map_v1.2.0_%s_beam.txt" % (
cversion, region, region, cversion)
yfile3 = os.environ[
"WORK"] + "/data/depot/tilec/v1.2.0_20200324/map_v1.2.0_%s_%s/tilec_single_tile_%s_cmb_deprojects_comptony_map_v1.2.0_%s.fits" % (
cversion, region, region, cversion)
# Reconvolve to the same beam and filter out modes < ellmin
ls, obells = np.loadtxt(bfile, unpack=True)
obeam = maps.interp(ls, obells)(modlmap)
beam_ratio = kbeam / obeam
beam_ratio[~np.isfinite(beam_ratio)] = 0
kmask = maps.mask_kspace(mask.shape, mask.wcs, lmin=lmin, lmax=30000)
# Get coadd map of reference array
kmap = enmap.fft(
dm.get_coadd("s15", region, array, srcfree=True, ncomp=1)[0] * mask)
# Get pixel window correction
pwin = tutils.get_pixwin(mask.shape[-2:])
bpfile = "data/" + dm.get_bandpass_file_name(array)
# Apply a filter that converts array map to Compton Y units (Eq 8)
f = tfg.get_mix_bandpassed([bpfile],
'tSZ',
ccor_cen_nus=[freqs[array]],
ccor_beams=[lbeam])[0]
f2d = maps.interp(ells, f)(modlmap)
filt = kmask / pwin / f2d
filt[~np.isfinite(filt)] = 0
imap = enmap.ifft(kmap * filt).real
def calculate_yy(bin_edges,arrays,region,version,cov_versions,beam_version,
effective_freq,overwrite,maxval,unsanitized_beam=False,do_weights=False,
pa1_shift = None,
pa2_shift = None,
pa3_150_shift = None,
pa3_090_shift = None,
no_act_color_correction=False, ccor_exp = -1,
sim_splits=None,unblind=False,all_analytic=False,beta_samples=None):
"""
We calculate the yy power spectrum as follows.
We restrict the Fourier modes in our analysis to those within bin_edges.
This way we don't carry irrelevant pixels and thus speed up the ability to MC.
We accept two covariance versions in cov_versions, which correspond to
[act_covariance_from_split_0,act_covariance_from_split_1,other_covs].
Thus the ACT auto covariances are pre-calculated
"""
arrays = arrays.split(',')
narrays = len(arrays)
if sim_splits is not None: assert not(unblind)
def warn(): print("WARNING: no bandpass file found. Assuming array ",dm.c['id']," has no response to CMB, tSZ and CIB.")
aspecs = tutils.ASpecs().get_specs
bandpasses = not(effective_freq)
savedir = tutils.get_save_path(version,region)
assert len(cov_versions)==3
covdirs = [tutils.get_save_path(cov_versions[i],region) for i in range(3)]
for covdir in covdirs: assert os.path.exists(covdir)
if not(overwrite):
assert not(os.path.exists(savedir)), \
"This version already exists on disk. Please use a different version identifier."
try: os.makedirs(savedir)
except:
if overwrite: pass
else: raise
mask = enmap.read_map(covdir+"tilec_mask.fits")
from scipy.ndimage.filters import gaussian_filter as smooth
pm = enmap.read_map("/scratch/r/rbond/msyriac/data/planck/data/pr2/COM_Mask_Lensing_2048_R2.00_car_deep56_interp_order0.fits")
wcs = pm.wcs
mask = enmap.enmap(smooth(pm,sigma=10),wcs) * mask
shape,wcs = mask.shape,mask.wcs
Ny,Nx = shape
modlmap = enmap.modlmap(shape,wcs)
omodlmap = modlmap.copy()
ells = np.arange(0,modlmap.max())
minell = maps.minimum_ell(shape,wcs)
sel = np.where(np.logical_and(modlmap>=bin_edges[0]-minell,modlmap<=bin_edges[-1]+minell))
modlmap = modlmap[sel]
bps = []
lbeams = []
kbeams = []
shifts = []
cfreqs = []
lmins = []
lmaxs = []
names = []
for i,qid in enumerate(arrays):
dm = sints.models[sints.arrays(qid,'data_model')](region=mask,calibrated=True)
if dm.name=='act_mr3':
season,array1,array2 = sints.arrays(qid,'season'),sints.arrays(qid,'array'),sints.arrays(qid,'freq')
array = '_'.join([array1,array2])
elif dm.name=='planck_hybrid':
season,patch,array = None,None,sints.arrays(qid,'freq')
else:
raise ValueError
lmin,lmax,hybrid,radial,friend,cfreq,fgroup,wrfit = aspecs(qid)
lmins.append(lmin)
lmaxs.append(lmax)
names.append(qid)
cfreqs.append(cfreq)
if bandpasses:
try:
fname = dm.get_bandpass_file_name(array)
bps.append("data/"+fname)
if (pa1_shift is not None) and 'PA1' in fname:
shifts.append(pa1_shift)
elif (pa2_shift is not None) and 'PA2' in fname:
shifts.append(pa2_shift)
elif (pa3_150_shift is not None) and ('PA3' in fname) and ('150' in fname):
shifts.append(pa3_150_shift)
elif (pa3_090_shift is not None) and ('PA3' in fname) and ('090' in fname):
shifts.append(pa3_90_shift)
else:
shifts.append(0)
except:
warn()
bps.append(None)
else:
try: bps.append(cfreq)
except:
warn()
bps.append(None)
kbeam = tutils.get_kbeam(qid,modlmap,sanitize=not(unsanitized_beam),version=beam_version,planck_pixwin=True)
if dm.name=='act_mr3':
lbeam = tutils.get_kbeam(qid,ells,sanitize=not(unsanitized_beam),version=beam_version,planck_pixwin=False) # note no pixwin but doesnt matter since no ccorr for planck
elif dm.name=='planck_hybrid':
lbeam = None
else:
raise ValueError
lbeams.append(lbeam)
kbeams.append(kbeam.copy())
# Make responses
responses = {}
def _get_response(comp,param_override=None):
if bandpasses:
if no_act_color_correction:
r = tfg.get_mix_bandpassed(bps, comp, bandpass_shifts=shifts,
param_dict_override=param_override)
else:
r = tfg.get_mix_bandpassed(bps, comp, bandpass_shifts=shifts,
ccor_cen_nus=cfreqs, ccor_beams=lbeams,
ccor_exps = [ccor_exp] * narrays,
param_dict_override=param_override)
else:
r = tfg.get_mix(bps, comp,param_dict_override=param_override)
return r
for comp in ['tSZ','CMB','CIB']:
responses[comp] = _get_response(comp,None)
from tilec.utils import is_planck
ilcgens = []
okcoadds = []
for splitnum in range(2):
covdir = covdirs[splitnum]
kcoadds = []
for i,qid in enumerate(arrays):
lmin = lmins[i]
lmax = lmaxs[i]
if is_planck(qid):
dm = sints.models[sints.arrays(qid,'data_model')](region=mask,calibrated=True)
_,kcoadd,_ = kspace.process(dm,region,qid,mask,
skip_splits=True,
splits_fname=sim_splits[i] if sim_splits is not None else None,
inpaint=False,fn_beam = None,
plot_inpaint_path = None,
split_set=splitnum)
else:
kcoadd_name = covdir + "kcoadd_%s.npy" % qid
kcoadd = enmap.enmap(np.load(kcoadd_name),wcs)
kmask = maps.mask_kspace(shape,wcs,lmin=lmin,lmax=lmax)
dtype = kcoadd.dtype
kcoadds.append((kcoadd.copy()*kmask)[sel])
kcoadds = enmap.enmap(np.stack(kcoadds),wcs)
okcoadds.append(kcoadds.copy())
# Read Covmat
ctheory = ilc.CTheory(modlmap)
nells = kcoadds[0].size
cov = np.zeros((narrays,narrays,nells))
for aindex1 in range(narrays):
for aindex2 in range(aindex1,narrays):
qid1 = names[aindex1]
qid2 = names[aindex2]
if is_planck(names[aindex1]) or is_planck(names[aindex2]) or all_analytic:
lmin,lmax,hybrid,radial,friend,f1,fgroup,wrfit = aspecs(qid1)
lmin,lmax,hybrid,radial,friend,f2,fgroup,wrfit = aspecs(qid2)
# If both are Planck and same array, get white noise from last bin
icov = ctheory.get_theory_cls(f1,f2,a_cmb=1,a_gal=0.8)*kbeams[aindex1]*kbeams[aindex2]
if aindex1==aindex2:
pcov = enmap.enmap(np.load(covdirs[2]+"tilec_hybrid_covariance_%s_%s.npy" % (names[aindex1],names[aindex2])),wcs)
pbin_edges = np.append(np.arange(500,3000,200) ,[3000,4000,5000,5800])
pbinner = stats.bin2D(omodlmap,pbin_edges)
w = pbinner.bin(pcov)[1][-1]
icov = icov + w
else:
icov = np.load(covdir+"tilec_hybrid_covariance_%s_%s.npy" % (names[aindex1],names[aindex2]))[sel]
if aindex1==aindex2:
icov[modlmap<lmins[aindex1]] = maxval
icov[modlmap>lmaxs[aindex1]] = maxval
cov[aindex1,aindex2] = icov
cov[aindex2,aindex1] = icov
assert np.all(np.isfinite(cov))
ilcgen = ilc.HILC(modlmap,np.stack(kbeams),cov=cov,responses=responses,invert=True)
ilcgens.append(ilcgen)
solutions = ['tSZ','tSZ-CMB','tSZ-CIB']
ypowers = {}
w2 = np.mean(mask**2.)
binner = stats.bin2D(modlmap,bin_edges)
np.random.seed(100)
blinding = np.random.uniform(0.8,1.2) if not(unblind) else 1
def _get_ypow(sname,dname,dresponse=None,dcmb=False):
if dresponse is not None:
assert dname is not None
for splitnum in range(2):
ilcgens[splitnum].add_response(dname,dresponse)
ykmaps = []
for splitnum in range(2):
if dcmb:
assert dname is not None
ykmap = ilcgens[splitnum].multi_constrained_map(okcoadds[splitnum],sname,[dname,"CMB"])
else:
if dname is None:
ykmap = ilcgens[splitnum].standard_map(okcoadds[splitnum],sname)
else:
ykmap = ilcgens[splitnum].constrained_map(okcoadds[splitnum],sname,dname)
ykmaps.append(ykmap.copy())
ypower = (ykmaps[0]*ykmaps[1].conj()).real / w2
return binner.bin(ypower)[1] * blinding
# The usual solutions
for solution in solutions:
sols = solution.split('-')
if len(sols)==2:
sname = sols[0]
dname = sols[1]
elif len(sols)==1:
sname = sols[0]
dname = None
else:
raise ValueError
ypowers[solution] = _get_ypow(sname,dname,dresponse=None)
# The CIB SED samples
if beta_samples is not None:
y_bsamples = []
y_bsamples_cmb = []
for beta in beta_samples:
pdict = tfg.default_dict.copy()
pdict['beta_CIB'] = beta
response = _get_response("CIB",param_override=pdict)
y_bsamples.append( _get_ypow("tSZ","iCIB",dresponse=response,dcmb=False) )
y_bsamples_cmb.append( _get_ypow("tSZ","iCIB",dresponse=response,dcmb=True) )
else:
y_bsamples = None
y_bsamples_cmb = None
return binner.centers,ypowers,y_bsamples,y_bsamples_cmb
def build_and_save_ilc(arrays,region,version,cov_version,beam_version,
solutions,beams,chunk_size,
effective_freq,overwrite,maxval,unsanitized_beam=False,do_weights=False,
pa1_shift = None,
pa2_shift = None,
pa3_150_shift = None,
pa3_090_shift = None,
no_act_color_correction=False, ccor_exp = -1,
isotropize=False, isotropize_width=20):
print("Chunk size is ", chunk_size*64./8./1024./1024./1024., " GB.")
def warn(): print("WARNING: no bandpass file found. Assuming array ",dm.c['id']," has no response to CMB, tSZ and CIB.")
aspecs = tutils.ASpecs().get_specs
bandpasses = not(effective_freq)
savedir = tutils.get_save_path(version,region)
covdir = tutils.get_save_path(cov_version,region)
assert os.path.exists(covdir)
if not(overwrite):
assert not(os.path.exists(savedir)), \
"This version already exists on disk. Please use a different version identifier."
try: os.makedirs(savedir)
except:
if overwrite: pass
else: raise
mask = enmap.read_map(covdir+"tilec_mask.fits")
shape,wcs = mask.shape,mask.wcs
Ny,Nx = shape
modlmap = enmap.modlmap(shape,wcs)
arrays = arrays.split(',')
narrays = len(arrays)
kcoadds = []
kbeams = []
bps = []
names = []
lmins = []
lmaxs = []
shifts = []
cfreqs = []
lbeams = []
ells = np.arange(0,modlmap.max())
for i,qid in enumerate(arrays):
dm = sints.models[sints.arrays(qid,'data_model')](region=mask,calibrated=True)
lmin,lmax,hybrid,radial,friend,cfreq,fgroup,wrfit = aspecs(qid)
cfreqs.append(cfreq)
lmins.append(lmin)
lmaxs.append(lmax)
names.append(qid)
if dm.name=='act_mr3':
season,array1,array2 = sints.arrays(qid,'season'),sints.arrays(qid,'array'),sints.arrays(qid,'freq')
array = '_'.join([array1,array2])
elif dm.name=='planck_hybrid':
season,patch,array = None,None,sints.arrays(qid,'freq')
else:
raise ValueError
kcoadd_name = covdir + "kcoadd_%s.npy" % qid
kmask = maps.mask_kspace(shape,wcs,lmin=lmin,lmax=lmax)
kcoadd = enmap.enmap(np.load(kcoadd_name),wcs)
dtype = kcoadd.dtype
kcoadds.append(kcoadd.copy()*kmask)
kbeam = tutils.get_kbeam(qid,modlmap,sanitize=not(unsanitized_beam),version=beam_version,planck_pixwin=True)
if dm.name=='act_mr3':
lbeam = tutils.get_kbeam(qid,ells,sanitize=not(unsanitized_beam),version=beam_version,planck_pixwin=False) # note no pixwin but doesnt matter since no ccorr for planck
elif dm.name=='planck_hybrid':
lbeam = None
else:
raise ValueError
lbeams.append(lbeam)
kbeams.append(kbeam.copy())
if bandpasses:
try:
fname = dm.get_bandpass_file_name(array)
bps.append("data/"+fname)
if (pa1_shift is not None) and 'PA1' in fname:
shifts.append(pa1_shift)
elif (pa2_shift is not None) and 'PA2' in fname:
shifts.append(pa2_shift)
elif (pa3_150_shift is not None) and ('PA3' in fname) and ('150' in fname):
shifts.append(pa3_150_shift)
elif (pa3_090_shift is not None) and ('PA3' in fname) and ('090' in fname):
shifts.append(pa3_90_shift)
else:
shifts.append(0)
except:
warn()
bps.append(None)
else:
try: bps.append(cfreq)
except:
warn()
bps.append(None)
kcoadds = enmap.enmap(np.stack(kcoadds),wcs)
# Read Covmat
cov = maps.SymMat(narrays,shape[-2:])
for aindex1 in range(narrays):
for aindex2 in range(aindex1,narrays):
icov = enmap.enmap(np.load(covdir+"tilec_hybrid_covariance_%s_%s.npy" % (names[aindex1],names[aindex2])),wcs)
if isotropize:
bin_edges = np.append([0.],np.arange(min(lmins),modlmap.max(),isotropize_width))
binner = stats.bin2D(modlmap,bin_edges)
ls,c1d = binner.bin(icov)
icov = maps.interp(ls,c1d)(modlmap)
if aindex1==aindex2:
icov[modlmap<lmins[aindex1]] = maxval
icov[modlmap>lmaxs[aindex1]] = maxval
cov[aindex1,aindex2] = icov
cov.data = enmap.enmap(cov.data,wcs,copy=False)
covfunc = lambda sel: cov.to_array(sel,flatten=True)
assert cov.data.shape[0]==((narrays*(narrays+1))/2) # FIXME: generalize
assert np.all(np.isfinite(cov.data))
# Make responses
responses = {}
for comp in ['tSZ','CMB','CIB']:
if bandpasses:
if no_act_color_correction:
responses[comp] = tfg.get_mix_bandpassed(bps, comp, bandpass_shifts=shifts)
else:
responses[comp] = tfg.get_mix_bandpassed(bps, comp, bandpass_shifts=shifts,
ccor_cen_nus=cfreqs, ccor_beams=lbeams,
ccor_exps = [ccor_exp] * narrays)
else:
responses[comp] = tfg.get_mix(bps, comp)
ilcgen = ilc.chunked_ilc(modlmap,np.stack(kbeams),covfunc,chunk_size,responses=responses,invert=True)
# Initialize containers
solutions = solutions.split(',')
data = {}
kcoadds = kcoadds.reshape((narrays,Ny*Nx))
for solution in solutions:
data[solution] = {}
comps = solution.split('-')
data[solution]['comps'] = comps
if len(comps)<=2:
data[solution]['noise'] = enmap.zeros((Ny*Nx),wcs)
if len(comps)==2:
data[solution]['cnoise'] = enmap.zeros((Ny*Nx),wcs)
data[solution]['kmap'] = enmap.zeros((Ny*Nx),wcs,dtype=dtype) # FIXME: reduce dtype?
if do_weights and len(comps)<=2:
for qid in arrays:
data[solution]['weight_%s' % qid] = enmap.zeros((Ny*Nx),wcs)
for chunknum,(hilc,selchunk) in enumerate(ilcgen):
print("ILC on chunk ", chunknum+1, " / ",int(modlmap.size/chunk_size)+1," ...")
for solution in solutions:
comps = data[solution]['comps']
if len(comps)==1: # GENERALIZE
data[solution]['noise'][selchunk] = hilc.standard_noise(comps[0])
if do_weights: weight = hilc.standard_weight(comps[0])
data[solution]['kmap'][selchunk] = hilc.standard_map(kcoadds[...,selchunk],comps[0])
elif len(comps)==2:
data[solution]['noise'][selchunk] = hilc.constrained_noise(comps[0],comps[1])
data[solution]['cnoise'][selchunk] = hilc.cross_noise(comps[0],comps[1])
ret = hilc.constrained_map(kcoadds[...,selchunk],comps[0],comps[1],return_weight=do_weights)
if do_weights:
data[solution]['kmap'][selchunk],weight = ret
else:
data[solution]['kmap'][selchunk] = ret
elif len(comps)>2:
data[solution]['kmap'][selchunk] = np.nan_to_num(hilc.multi_constrained_map(kcoadds[...,selchunk],comps[0],*comps[1:]))
if len(comps)<=2 and do_weights:
for qind,qid in enumerate(arrays):
data[solution]['weight_%s' % qid][selchunk] = weight[qind]
del ilcgen,cov
# Reshape into maps
name_map = {'CMB':'cmb','tSZ':'comptony','CIB':'cib'}
beams = beams.split(',')
for solution,beam in zip(solutions,beams):
comps = "tilec_single_tile_"+region+"_"
comps = comps + name_map[data[solution]['comps'][0]]+"_"
if len(data[solution]['comps'])>1: comps = comps + "deprojects_"+ '_'.join([name_map[x] for x in data[solution]['comps'][1:]]) + "_"
comps = comps + version
if do_weights and len(data[solution]['comps'])<=2:
for qind,qid in enumerate(arrays):
enmap.write_map("%s/%s_%s_weight.fits" % (savedir,comps,qid), enmap.enmap(data[solution]['weight_%s' % qid].reshape((Ny,Nx)),wcs))
try:
noise = enmap.enmap(data[solution]['noise'].reshape((Ny,Nx)),wcs)
enmap.write_map("%s/%s_noise.fits" % (savedir,comps),noise)
except: pass
try:
cnoise = enmap.enmap(data[solution]['cnoise'].reshape((Ny,Nx)),wcs)
enmap.write_map("%s/%s_cross_noise.fits" % (savedir,comps),cnoise)
except: pass
ells = np.arange(0,modlmap.max(),1)
try:
fbeam = float(beam)
kbeam = maps.gauss_beam(modlmap,fbeam)
lbeam = maps.gauss_beam(ells,fbeam)
except:
qid = beam
bfunc = lambda x: tutils.get_kbeam(qid,x,version=beam_version,sanitize=not(unsanitized_beam),planck_pixwin=False)
kbeam = bfunc(modlmap)
lbeam = bfunc(ells)
kmap = enmap.enmap(data[solution]['kmap'].reshape((Ny,Nx)),wcs)
smap = enmap.ifft(kbeam*kmap,normalize='phys').real
enmap.write_map("%s/%s.fits" % (savedir,comps),smap)
io.save_cols("%s/%s_beam.txt" % (savedir,comps),(ells,lbeam),header="ell beam")
enmap.write_map(savedir+"/tilec_mask.fits",mask)
taper, w2 = maps.get_taper_deg(shape, wcs, args.tapwidth)
w3 = np.mean(taper**3.)
imap = imap * taper
_, kmap, _ = fc.power2d(imap, rot=False)
# Inputs
ikalm = lensing.phi_to_kappa(
maps.change_alm_lmax(
hp.read_alm(sim_location + "fullskyPhi_alm_%s.fits" % (sindex)),
mlmax))
ikmap = cs.alm2map(ikalm, enmap.zeros((1, ) + shape[-2:], wcs), spin=0)
ikmap = ikmap * taper
_, kikmap, _ = fc.power2d(ikmap)
tmask = maps.mask_kspace(shape, wcs, lmin=args.lmint, lmax=args.lmaxt)
feed_dict = {
'X': kmap[0],
'Y': kmap[1],
'uC_T_E': theory.lCl('TE', modlmap),
'uC_T_T': theory.lCl('TT', modlmap),
'uC_E_E': theory.lCl('EE', modlmap),
'tC_T_T': theory.lCl('TT', modlmap),
'tC_T_E': theory.lCl('TE', modlmap),
'tC_E_E': theory.lCl('EE', modlmap),
}
krecon = norm * symlens.unnormalized_quadratic_estimator(shape,
wcs,
feed_dict,
"hu_ok",
'TE',
# Say we want analytic RDN0 for the TTTE estimator
XY='TE'
UV='TE'
# example geometry, you can use your own map's geometry
shape,wcs = maps.rect_geometry(width_deg=25.,px_res_arcmin=2.0)
modlmap = enmap.modlmap(shape,wcs)
# symlens QEs always need you to specify 2d Fourier space masks
# for the CMB, and also for the final lensing k-mask
# For the CMB I use our typical ranges
ellmin = 500 ; ellmax = 3000
# and create a 2d mask (you can pass lxcut, lycut etc. if you want
# or use the 2d masks you already have for your analysis)
cmb_kmask = maps.mask_kspace(shape,wcs,lmin=ellmin,lmax=ellmax)
# Similarly, I create a final lensing k-mask which can go to lower L
Lmin = 100 ; Lmax = 3000
lens_kmask = maps.mask_kspace(shape,wcs,lmin=Lmin,lmax=Lmax)
# You always need a feed_dict to specify various 2d power spectra
feed_dict = {}
# We need some theory spectra. You'll have your own way to get them,
# but I'll load them with orphics
theory = cosmology.default_theory()
# The first set of 2d spectra you need are the "uC" spectra. In the original
# papers, these were unlensed spectra, but now we know to use the lensed
# (or better yet for TT, the TgradT) spectra. These are the CMB signal
# only spectra that appear in numerators of the norm/response and filters
feed_dict['uC_T_T'] = theory.lCl('TT',modlmap) # interpolate on to modlmap
def _filter(self,imap,ai):
kmask = maps.mask_kspace(self.shape,self.wcs,lmin=self.ellmins[ai],lmax=self.ellmaxes[ai])
return maps.filter_map(imap,kmask)
def _init_qests(self):
mlist = ['e', 's', 'r']
self.qest = {}
tellminY = 500
tellmaxY = 3000
pellminY = 500
pellmaxY = 3000
tellminX = 500
tellmaxX = 3000
pellminX = 500
pellmaxX = 3000
kellmin = 80
kellmax = 3000
self.kellmin = kellmin
self.kellmax = kellmax
for m in mlist:
modlmap_dat = enmap.modlmap(self.shape[m], self.wcs[m])
nT = modlmap_dat.copy() * 0.
nP = modlmap_dat.copy() * 0.
lbeam = modlmap_dat.copy() * 0. + 1.
fMaskCMB_TX = fmaps.mask_kspace(self.shape[m],
self.wcs[m],
lmin=tellminX,
lmax=tellmaxX)
fMaskCMB_TY = fmaps.mask_kspace(self.shape[m],
self.wcs[m],
lmin=tellminY,
lmax=tellmaxY)
fMaskCMB_PX = fmaps.mask_kspace(self.shape[m],
self.wcs[m],
lmin=pellminX,
lmax=pellmaxX)
fMaskCMB_PY = fmaps.mask_kspace(self.shape[m],
self.wcs[m],
lmin=pellminY,
lmax=pellmaxY)
fMask = fmaps.mask_kspace(self.shape[m],
self.wcs[m],
lmin=kellmin,
lmax=kellmax)
with io.nostdout():
self.qest[m] = Estimator(
self.shape[m],
self.wcs[m],
self.theory,
theorySpectraForNorm=None,
noiseX2dTEB=[nT, nP, nP],
noiseY2dTEB=[nT, nP, nP],
fmaskX2dTEB=[fMaskCMB_TX, fMaskCMB_PX, fMaskCMB_PX],
fmaskY2dTEB=[fMaskCMB_TY, fMaskCMB_PY, fMaskCMB_PY],
fmaskKappa=fMask,
kBeamX=lbeam,
kBeamY=lbeam,
doCurl=False,
TOnly=True,
halo=True,
uEqualsL=True,
gradCut=None,
verbose=False,
bigell=self.lmax)
kappa = lensing.nfw_kappa(mass,thetas*utils.arcmin,cc,zL=z,concentration=conc,overdensity=180,critical=False,atClusterZ=False)
hthetas,hkappa = np.loadtxt("data/hdv_unfiltered.csv",unpack=True,delimiter=',')
pl = io.Plotter(xyscale='loglog', xlabel='$\\theta$ [arcmin]', ylabel='$\\kappa$')
pl.add(thetas,kappa)
pl.add(hthetas,hkappa,ls='--')
pl.done('test_uhdv.png')
pl = io.Plotter(xyscale='linlin', xlabel='$\\theta$ [arcmin]', ylabel='$\\kappa$')
pl.add(hthetas,hkappa/maps.interp(thetas,kappa)(hthetas),ls='--')
pl.hline(y=1)
pl.done('test_uhdv_ratio.png')
shape,wcs = enmap.geometry(pos=(0,0),shape=(512,512),res=0.2 * utils.arcmin,proj='plain')
kmask = maps.mask_kspace(shape,wcs,lmax=8095)
bin_edges_arcmin= np.arange(0,15,0.4)
cents,k1d = lensing.binned_nfw(mass,z,conc,cc,shape,wcs,bin_edges_arcmin,overdensity=180.,critical=False,at_cluster_z=False,kmask=kmask)
hcents,hk1d = np.loadtxt("data/hdv_filtered_kappa.csv",unpack=True,delimiter=',')
pl = io.Plotter(xyscale='linlin', xlabel='$\\theta$ [arcmin]', ylabel='$\\kappa$')
pl.add(cents*180.*60/np.pi,k1d)
pl.add(hcents,hk1d,ls='--')
pl.done('test_hdv.png')
pl = io.Plotter(xyscale='linlin', xlabel='$\\theta$ [arcmin]', ylabel='$\\kappa$')
pl.add(hcents,hk1d/maps.interp(cents*180.*60/np.pi,k1d)(hcents),ls='--')
pl.hline(y=1)
pl.done('test_hdv_ratio.png')
weight=None,
)
taper = taper[0]
# get geometry and Fourier info
shape = kstamp.shape
wcs = kstamp.wcs
modlmap = enmap.modlmap(shape, wcs)
assert wcsutils.equal(kstamp.wcs, lstamp.wcs)
# evaluate the 2D Gaussian beam on an isotropic Fourier grid
beam2d = maps.gauss_beam(modlmap, fwhm)
# build Fourier space masks for lensing reconstruction
xmask = maps.mask_kspace(shape, wcs, lmin=xlmin, lmax=xlmax)
ymask = maps.mask_kspace(shape,
wcs,
lmin=ylmin,
lmax=ylmax,
lxcut=ylcut,
lycut=ylcut)
kmask = maps.mask_kspace(shape, wcs, lmin=klmin, lmax=klmax)
# get theory spectrum and build interpolated 2D Fourier CMB from theory and maps
theory = cosmology.default_theory()
ucltt2d = theory.lCl('TT', modlmap)
# total spectrum includes beam-deconvolved noise
npower = (nlevel * np.pi / 180. / 60.)**2.
tcltt2d = ucltt2d + npower / beam2d**2.
2. ACT TT only
3. Planck-ACT TT grad clean
4. Planck-ACT TT ILC grad clean
1. Planck TT+pol
2. ACT TT+pol
3. Planck-ACT TT grad clean + pol
4. Planck-ACT TT ILC grad clean + pol
"""
deg = 5.
px = 2.0
shape, wcs = maps.rect_geometry(width_deg=deg, px_res_arcmin=px)
modlmap = enmap.modlmap(shape, wcs)
tmask = maps.mask_kspace(shape,
wcs,
lmin=tellmin,
lmax=tellmax,
lxcut=20,
lycut=20)
pmask = maps.mask_kspace(shape,
wcs,
lmin=pellmin,
lmax=pellmax,
lxcut=20,
lycut=20)
tsnoise, tcnoise, tscnoise = get_ilc_noise(modlmap)
tenoise, tbnoise = get_pol_noise(modlmap)
lcltt, lclee, lclte, lclbb, clkk = get_cmb(modlmap)
def get_mv(nls):
comps = comps + version
fname = "%s%s.fits" % (savedir,comps)
cs = []
for isotype in ['iso_v1.0.0_rc','v1.0.0_rc']:
lname = fname.replace('$VERSION',isotype)
print(lname)
imap = enmap.read_map(lname)
kmask = maps.mask_kspace(imap.shape,imap.wcs, lxcut = 40, lycut = 40)
k = enmap.fft(imap,normalize='phys') #* kmask
p = (k*k.conj()).real
modlmap = imap.modlmap()
if '_act_' in fname:
bin_edges = np.arange(500,8000,20)
else:
bin_edges = np.arange(20,8000,20)
binner = stats.bin2D(modlmap,bin_edges)
cents,c1d = binner.bin(p)
cs.append(c1d.copy())
r = (cs[0]-cs[1])/cs[1]
responses[comp] = tfg.get_mix(bps, comp)
ilcgen = ilc.chunked_ilc(modlmap,
np.stack(kbeams),
covfunc,
chunk_size,
responses=responses,
invert=True)
Ny, Nx = eshape[-2:]
# Initialize containers
data = {}
for qind, qid in enumerate(aids):
lmin = lmins[qind]
lmax = lmaxs[qind]
kmask = maps.mask_kspace(eshape, ewcs, lmin=lmin, lmax=lmax)
kcoadds[qind] = kcoadds[qind] * kmask
# !!!!
# dy = 45
# dx = 19
# c1 = cov.to_array(flatten=False)[:,:,dy,dx]
# c2 = cov.to_array(flatten=False)[:,:,dy-1,dx]
# v1 = kcoadds[:,dy,dx]
# v2 = kcoadds[:,dy-1,dx]
# print(np.abs(v1))
# print(np.abs(v2))
# # np.save("cov_bad_pixel.npy",c1)
# # np.save("cov_good_pixel.npy",c2)
# # np.save("vec_bad_pixel.npy",v1)
# # np.save("vec_good_pixel.npy",v2)
my_tasks = range(nsims)
theory = cosmology.default_theory()
cov = theory.lCl('TT',modlmap)
mgen = maps.MapGen((1,)+shape,wcs,cov=cov[None,None])
fwhm = 1.5
wnoise = 40.
kbeam = maps.gauss_beam(modlmap,fwhm)
feed_dict = {}
lmin = 200
lmax = 3000
Lmin = 40
Lmax = 3000
xmask = maps.mask_kspace(shape,wcs,lmin=lmin,lmax=lmax)
ymask = xmask
kmask = maps.mask_kspace(shape,wcs,lmin=Lmin,lmax=Lmax)
feed_dict['uC_T_T'] = cov
feed_dict['tC_T_T'] = cov + (wnoise*np.pi/180/60)**2 / kbeam**2
qe = symlens.QE(shape,wcs,feed_dict,'hu_ok','TT',xmask=xmask,ymask=ymask,kmask=kmask)
s = stats.Stats()
for task in my_tasks:
cmb = maps.filter_map(mgen.get_map(seed=(1,task))[0],kbeam)
nseed = (2,task)
nmap = maps.white_noise(shape,wcs,noise_muK_arcmin=None,seed=nseed,ipsizemap=pmap,div=ivar)
obs = cmb + nmap
unlensedEqualsLensed=False,
useTotal=False,
TCMB=2.7255e6,
lpad=9000,
get_dimensionless=False)
shape, wcs = maps.rect_geometry(width_arcmin=10., px_res_arcmin=0.5)
lmax = 8000
ells = np.arange(0, lmax, 1)
ps = theory.uCl('TT', ells).reshape((1, 1, lmax))
modrmap = enmap.modrmap(shape, wcs)
modlmap = enmap.modlmap(shape, wcs)
ksigma = 4.0 * np.pi / 180. / 180.
kamp = 0.1
kappa = kamp * np.exp(-modrmap**2. / 2. / ksigma**2.)
tkmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=6000)
kkmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=7000)
qest = lensing.qest(shape, wcs, theory, kmask=tkmask, kmask_K=kkmask)
phi, _ = lensing.kappa_to_phi(kappa, modlmap, return_fphi=True)
grad_phi = enmap.grad(phi)
lens_order = 5
N = 1000
bin_edges = np.arange(0, 10., 1.0)
binner = stats.bin2D(modrmap * 180. * 60 / np.pi, bin_edges)
mystats = stats.Stats()
fkappa = maps.filter_map(kappa, kkmask)
cents, yt = binner.bin(fkappa)
if rank==0: print("Starting sims...")
# Stats
Nsims = args.Nclusters
Njobs = Nsims
num_each,each_tasks = mpi.mpi_distribute(Njobs,numcores)
if rank==0: print ("At most ", max(num_each) , " tasks...")
my_tasks = each_tasks[rank]
mstats = stats.Stats(comm)
np.random.seed(rank)
# QE
tellmin = modlmap[modlmap>2].min(); tellmax = 8000; kellmin = tellmin ; kellmax = 8096
tmask = maps.mask_kspace(shape,wcs,lmin=tellmin,lmax=tellmax)
kmask = maps.mask_kspace(shape,wcs,lmin=kellmin,lmax=kellmax)
qest = lensing.qest(shape,wcs,theory,noise2d=kbeam*0.+(noise_uK_rad)**2.,beam2d=kbeam,kmask=tmask,kmask_K=kmask,pol=False,grad_cut=2000,unlensed_equals_lensed=False)
for i,task in enumerate(my_tasks):
if (i+1)%10==0 and rank==0: print(i+1)
unlensed = mg.get_map()
noise_map = ng.get_map()
lensed = maps.filter_map(enlensing.displace_map(unlensed, alpha_pix, order=lens_order),kbeam)
stamp = lensed + noise_map
if task==0: io.plot_img(stamp,pout_dir+"cmb_noisy.png")
recon = qest.kappa_from_map("TT",stamp)
cents, recon1d = binner.bin(recon)
noise_t = 10.0
noise_p = 10.0 * np.sqrt(2.)
fwhm = 1.5
kbeam = maps.gauss_beam(fwhm, mc.modlmap)
ells = np.arange(0, 3000, 1)
lbeam = maps.gauss_beam(fwhm, ells)
ntt = np.nan_to_num((noise_t * np.pi / 180. / 60.)**2. / kbeam**2.)
nee = np.nan_to_num((noise_p * np.pi / 180. / 60.)**2. / kbeam**2.)
nbb = np.nan_to_num((noise_p * np.pi / 180. / 60.)**2. / kbeam**2.)
lntt = np.nan_to_num((noise_t * np.pi / 180. / 60.)**2. / lbeam**2.)
lnee = np.nan_to_num((noise_p * np.pi / 180. / 60.)**2. / lbeam**2.)
lnbb = np.nan_to_num((noise_p * np.pi / 180. / 60.)**2. / lbeam**2.)
ellmin = 20
ellmax = 3000
xmask = maps.mask_kspace(shape, wcs, lmin=ellmin, lmax=ellmax)
ymask = xmask
Als = {}
for pol in pols:
with bench.show("ALcalc"):
AL = mc.AL(pol,
xmask,
ymask,
ntt,
nee,
nbb,
theory=theory,
hdv=hdv,
cache=cache)
Als[pol] = AL.copy()
from symlens.factorize import e
shape, wcs = maps.rect_geometry(width_deg=20., px_res_arcmin=1.5, proj='plain')
theory = cosmology.default_theory()
modlmap = enmap.modlmap(shape, wcs)
hardening = 'src'
# Lmax = 2000
# cluster = False
Lmax = 6000
cluster = True
if cluster:
xmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=2000)
ymask = maps.mask_kspace(shape, wcs, lmin=100, lmax=6000)
lxmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=2000)
lymask = maps.mask_kspace(shape, wcs, lmin=100, lmax=6000)
estimator = 'hdv'
else:
xmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=3500)
ymask = maps.mask_kspace(shape, wcs, lmin=100, lmax=3500)
lxmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=3500)
lymask = maps.mask_kspace(shape, wcs, lmin=100, lmax=3500)
estimator = 'hu_ok'
kmask = maps.mask_kspace(shape, wcs, lmin=20, lmax=Lmax)
feed_dict = {}
feed_dict['uC_T_T'] = theory.uCl('TT', modlmap)
nlevel = pnlevel
elif expid == 'act':
nid = 2
fwhm = afwhm
nlevel = anlevel
seed = (nid, task)
npower = (nlevel * np.pi / 180. / 60.)**2.
nmap = enmap.rand_map((1, ) + shape,
wcs,
np.ones(shape)[None, None] * npower,
seed=seed)
return maps.filter_map(cmb, maps.gauss_beam(modlmap, fwhm)) + nmap
# Make masks and feed_dict
xmask = maps.mask_kspace(shape, wcs, lmin=pellmin, lmax=pellmax)
ymask = maps.mask_kspace(shape,
wcs,
lmin=aellmin,
lmax=aellmax,
lxcut=alcut,
lycut=alcut)
kmask = maps.mask_kspace(shape, wcs, lmin=kellmin, lmax=kellmax)
fkmask = maps.gauss_beam(modlmap, ffwhm) if ffwhm is not None else 1
fwhm = pfwhm
abeam = maps.gauss_beam(modlmap, fwhm)
fwhm = afwhm
pbeam = maps.gauss_beam(modlmap, fwhm)
feed_dict = {}
feed_dict['uC_T_T'] = lcltt2d
nlevel = anlevel
