def __init__(self,ells,clgg,clkg=None,clkk=None,depth_map=None,lmax=None):
"""Initialize a catalog generator
Args:
ells: (nells,) array specifying multipoles at which clgg,clkg,clkk are defined
clgg: (nells,) array containing power spectrum of the field you want to Poisson sample from
clkg: (nells,) array containing cross-spectrum with the optional field you don't want to Poisson sample from (optional)
clkk: (nells,) array containing auto-spectrum of the field you don't want to Poisson sample from (optional)
depth_map: ndmap specifying depth. Max of this array will be divided out.
"""
ls = np.arange(0,ells.max(),1)
self.lmax = ls.max()
clgg = maps.interp(ells,clgg)(ls)
if clkg is not None:
assert clkk is not None
ncomp = 2
clkg = maps.interp(ells,clkg)(ls)
clkk = maps.interp(ells,clkk)(ls)
else:
ncomp = 1
self.shape = (ncomp,)+depth_map.shape[-2:]
self.wcs = depth_map.wcs
ps = np.zeros((ncomp,ncomp,ls.size))
ps[0,0] = clgg
if clkg is not None:
ps[1,1] = clkk
ps[0,1] = clkg
ps[1,0] = clkg
self.depth_map = depth_map/depth_map.max()
assert np.all(self.depth_map>=0)
self.ps = ps
self.ncomp = ncomp
def get_scaled_beams(ells,lbeam,cen_nu_ghz,nus_ghz,ccor_exp=-1):
"""
Scale a beam specified at multipoles ells with beam transfer
factors lbeam (normalized to 1 at ell=0) and central frequency
cen_nu_ghz onto the target frequencies nus_ghz with an exponent
ccor_exp.
Parameters
----------
ells : array_like
A 1d (nells,) array specifying what multipoles correspond to
beam transfer factors in lbeam
lbeam : array_like
A 1d (nells,) array specifying beam transfer factors normalized
such that lbeam(ell=0) = 1
cen_nu_ghz : float
The "central frequency" in GHz to which lbeam corresponds
nus_ghz : array_like
A 1d (nfreqs,) array of frequencies in GHz on to which the
beam lbeam should be scaled to
ccor_exp : float, optional
The exponent of the beam scaling. Defaults to -1, corresponding
to diffraction limited optics.
"""
from orphics import maps
fbnus = maps.interp(ells,lbeam[None,:],fill_value=(lbeam[0],lbeam[-1]))
bnus = fbnus(((cen_nu_ghz/nus_ghz)**(-ccor_exp))*ells[:,None])[0].swapaxes(0,1)
bnus = bnus / bnus[:,:1]
return bnus
def signal_average(cov,bin_edges=None,bin_width=40,kind=3,lmin=None,dlspace=True,return_bins=False,**kwargs):
"""
dcov = cov * ellfact
bin dcov in annuli
interpolate back on to ell
cov = dcov / ellfact
where ellfact = ell**2 if dlspace else 1
"""
modlmap = cov.modlmap()
assert np.all(np.isfinite(cov))
dcov = cov*modlmap**2. if dlspace else cov.copy()
if lmin is None:
minell = maps.minimum_ell(dcov.shape,dcov.wcs)
else:
minell = modlmap[modlmap<=lmin].max()
if bin_edges is None: bin_edges = np.append([2],np.arange(minell,modlmap.max(),bin_width))
binner = stats.bin2D(modlmap,bin_edges)
cents,c1d = binner.bin(dcov)
outcov = enmap.enmap(maps.interp(cents,c1d,kind=kind,fill_value=c1d[-1],**kwargs)(modlmap),dcov.wcs)
with np.errstate(invalid='ignore'): outcov = outcov / modlmap**2. if dlspace else outcov
outcov[modlmap<2] = 0
assert np.all(np.isfinite(outcov))
if return_bins: return cents,c1d,outcov
else: return outcov
def get_kbeam(qid,
modlmap,
sanitize=False,
version=None,
planck_pixwin=False,
**kwargs):
dmodel = sints.arrays(qid, 'data_model')
season = sints.arrays(qid, 'season')
region = sints.arrays(qid, 'region')
array = sints.arrays(qid, 'array')
freq = sints.arrays(qid, 'freq')
dm = sints.models[dmodel]()
gfreq = array + "_" + freq if not (is_planck(qid)) else freq
if planck_pixwin and (qid in [
'p01', 'p02', 'p03', 'p04', 'p05', 'p06', 'p07', 'p08'
]):
nside = get_nside(qid)
pixwin = hp.pixwin(nside=nside, pol=False)
ls = np.arange(len(pixwin))
assert pixwin.ndim == 1
assert ls.size in [6144, 3072]
pwin = maps.interp(ls, pixwin)(modlmap)
else:
pwin = 1.
return dm.get_beam(modlmap,
season=season,
patch=region,
array=gfreq,
kind='normalized',
sanitize=sanitize,
version=version,
**kwargs) * pwin
def get_power(map_list, ivar_list, a, b, mask, N=20):
"""
Calculate the average coadded flattened power spectrum P_{ab} used to generate simulation for the splits.
Inputs:
map_list: list of source free splits
ivar_list: list of the inverse variance maps splits
a: 0,1,2 for I,Q,U respectively
b:0,1,2 for I,Q,U, respectively
N: window to smooth the power spectrum by in the rolling average.
mask: apodizing mask
Output:
1D power spectrum accounted for w2 from 0 to 10000
"""
pmap = enmap.pixsizemap(map_list[0].shape, map_list[0].wcs)
cl_ab = []
n = len(map_list)
#calculate the coadd maps
if a != b:
coadd_a = coadd_mapnew(map_list, ivar_list, a)
coadd_b = coadd_mapnew(map_list, ivar_list, b)
else:
coadd_a = coadd_mapnew(map_list, ivar_list, a)
for i in range(n):
print(i)
if a != b:
d_a = map_list[i][a] - coadd_a
noise_a = d_a * np.sqrt(ivar_eff(i, ivar_list) / pmap) * mask
alm_a = cs.map2alm(noise_a, lmax=10000)
d_b = map_list[i][b] - coadd_b
noise_b = d_b * np.sqrt(ivar_eff(i, ivar_list) / pmap) * mask
alm_b = cs.map2alm(noise_b, lmax=10000)
cls = hp.alm2cl(alm_a, alm_b)
cl_ab.append(cls)
else:
d_a = map_list[i][a] - coadd_a
noise_a = d_a * np.sqrt(ivar_eff(i, ivar_list) / pmap) * mask
print("generating alms")
alm_a = cs.map2alm(noise_a, lmax=10000)
cls = hp.alm2cl(alm_a)
cl_ab.append(cls)
cl_ab = np.array(cl_ab)
sqrt_ivar = np.sqrt(ivar_eff(0, ivar_list) / pmap)
mask_ivar = sqrt_ivar * 0 + 1
mask_ivar[sqrt_ivar <= 0] = 0
mask = mask * mask_ivar
mask[mask <= 0] = 0
w2 = np.sum((mask**2) * pmap) / np.pi / 4.
power = 1 / n / (n - 1) * np.sum(cl_ab, axis=0)
ls = np.arange(len(power))
power[~np.isfinite(power)] = 0
power = rolling_average(power, N)
bins = np.arange(len(power))
power = maps.interp(bins, power)(ls)
return power / w2
def get_theory_dicts(nells=None, lmax=9000, grad=True):
thloc = os.path.dirname(
os.path.abspath(__file__)) + "/../data/" + config['theory_root']
ls = np.arange(lmax + 1)
ucls = {}
tcls = {}
theory = cosmology.loadTheorySpectraFromCAMB(thloc,
get_dimensionless=False)
ells, gt, ge, gb, gte = np.loadtxt(f"{thloc}_camb_1.0.12_grads.dat",
unpack=True,
usecols=[0, 1, 2, 3, 4])
if nells is None: nells = {'TT': 0, 'EE': 0, 'BB': 0}
ucls['TT'] = maps.interp(ells, gt)(ls) if grad else theory.lCl('TT', ls)
ucls['TE'] = maps.interp(ells, gte)(ls) if grad else theory.lCl('TE', ls)
ucls['EE'] = maps.interp(ells, ge)(ls) if grad else theory.lCl('EE', ls)
ucls['BB'] = maps.interp(ells, gb)(ls) if grad else theory.lCl('BB', ls)
ucls['kk'] = theory.gCl('kk', ls)
tcls['TT'] = theory.lCl('TT', ls) + nells['TT']
tcls['TE'] = theory.lCl('TE', ls)
tcls['EE'] = theory.lCl('EE', ls) + nells['EE']
tcls['BB'] = theory.lCl('BB', ls) + nells['BB']
return ucls, tcls
def filter_map(imap):
modlmap = imap.modlmap()
ells = np.arange(0, 8000, 1)
fcurve = np.exp(-(ells - 4000)**2. / 2. / 200**2.)
return maps.filter_map(imap, maps.interp(ells, fcurve)(modlmap))
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)
cbfile2 = tutils.get_generic_fname(tdir,
region2,
solution,
'cib',
cversion,
beam=True)
cmap1 = enmap.read_map(cfile1)
cmap2 = enmap.read_map(cfile2)
dmap1 = enmap.read_map(dfile1)
dmap2 = enmap.read_map(dfile2)
modlmap1 = cmap1.modlmap()
modlmap2 = cmap2.modlmap()
lsy1, by1 = np.loadtxt(ybfile1, unpack=True)
by12d = maps.interp(lsy1, by1)(modlmap1)
lsc1, bc1 = np.loadtxt(cbfile1, unpack=True)
bc12d = maps.interp(lsc1, bc1)(modlmap1)
beam_ratio1 = bc12d / by12d
beam_ratio1[~np.isfinite(beam_ratio1)] = 0
lsy2, by2 = np.loadtxt(ybfile2, unpack=True)
by22d = maps.interp(lsy2, by2)(modlmap2)
# ls,bc2 = np.loadtxt(cbfile2,unpack=True)
bc22d = maps.interp(lsc1, bc1)(modlmap2)
beam_ratio2 = bc22d / by22d
beam_ratio2[~np.isfinite(beam_ratio2)] = 0
ymap1 = maps.filter_map(enmap.read_map(yfile1), beam_ratio1)
ymap2 = maps.filter_map(enmap.read_map(yfile2), beam_ratio2)
def get_pol_noise(ells):
cents, sn1d, cn1d, scn1d, enoise, bnoise = np.loadtxt("lnoises.txt",
unpack=True)
return maps.interp(cents, enoise)(ells), maps.interp(cents, bnoise)(ells)
flmax = 3000
elif (qid1=='p03' or qid2=='p03') and (qid1 not in ['p01','p02']) and (qid2 not in ['p01','p02']):
flmax = 1000
else:
flmax = 300
if flmax<=flmin: #!!!!!!
io.save_cols("%sfgcov_%s_%s.txt" % (opath,qid1,qid2),(fells,fells*0))
else:
print("Rank %d doing task %d for array %s x %s with lmin %d and lmax %d ..." % (rank,task,qids[0],qids[1],flmin,flmax))
# ERROR CALC
c11 = stheory.get_theory_cls(f1,f1,a_cmb=1,a_gal=0.8)
n11 = maps.interp(ncents,n1d1)(ccents)/fbeam1(ccents)/fbeam1(ccents)
c22 = stheory.get_theory_cls(f2,f2,a_cmb=1,a_gal=0.8)
n22 = maps.interp(ncents,n1d2)(ccents)/fbeam2(ccents)/fbeam2(ccents)
c12 = stheory.get_theory_cls(f1,f2,a_cmb=1,a_gal=0.8)
n12 = maps.interp(ncents,n1d)(ccents)/fbeam1(ccents)/fbeam2(ccents)
c11[~np.isfinite(c11)] = 0
c12[~np.isfinite(c12)] = 0
c22[~np.isfinite(c22)] = 0
#cbin_edges = np.arange(20,8000,20)
cbin_edges = np.arange(20,8000,40)
LF = cosmology.LensForecast()
LF.loadGenericCls("11",ccents,c11,ellsNls=ccents,Nls=n11)
LF.loadGenericCls("22",ccents,c22,ellsNls=ccents,Nls=n22)
LF.loadGenericCls("12",ccents,c12,ellsNls=ccents,Nls=n12)
if region=='deep56':
fsky = 500./41252.
clkk = lc.getCl("cmb","cmb")
clkg = lc.getCl("cmb","g")
clgg = lc.getCl("g","g")
#theory = cosmology.default_theory()
#clkk = theory.gCl('kk',ells)
ledges = np.arange(80,1000,40)
for region in ['deep56','boss']:
dmask = sints.get_act_mr3_crosslinked_mask(region=region)
bmask = maps.binary_mask(dmask,0.95)
fsky = dmask.area()/np.pi/4. * (bmask.sum()/bmask.size)
pl = io.Plotter(xyscale='linlog',xlabel='l',ylabel='C')
pl.add(ells,clkk)
ls,nls = np.loadtxt("lensing_noise_act_planck_ilc_all_%s.txt" % region,unpack=True)
pl.add(ls,nls)
oells,onls = np.loadtxt("cl_K_ilc_noszK_ilc_noszs14&15_%s.txt" % region , unpack=True,usecols=[0,1])
pl.add(oells,onls-maps.interp(ells,clkk)(oells),ls='--')
pl.done("lensnoise_%s.png" % region)
lf = cosmology.LensForecast()
lf.loadKK(ells,clkk,ls,nls)
lf.loadKG(ells,clkg)
lf.loadGG(ells,clgg,ngal=0.026)
#lf.loadGG(ells,clgg,ngal=0.1)
snr = lf.sn(ledges,fsky,'kk')[0]
snr_kg = lf.sn(ledges,fsky,'kg')[0]
print(fsky*41252,snr,snr_kg)
"WORK"] + "/data/depot/tilec/v1.2.0_20200324/map_v1.2.0_%s_%s/tilec_single_tile_%s_cmb_map_v1.2.0_%s_beam.txt" % (
cversion, region, region, cversion)
yfile2 = os.environ[
"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)
if redo:
mask = sints.get_act_mr3_crosslinked_mask(region)
shape,wcs = mask.shape,mask.wcs
bfile = os.environ["WORK"] + "/data/depot/tilec/v1.2.0_20200324/map_v1.2.0_%s_%s/tilec_single_tile_%s_cmb%s_map_v1.2.0_%s_beam.txt" % (cversion,region,region,method,cversion)
yfile = os.environ["WORK"] + "/data/depot/tilec/v1.2.0_20200324/map_v1.2.0_%s_%s/tilec_single_tile_%s_cmb%s_map_v1.2.0_%s.fits" % (cversion,region,region,method,cversion)
w2 = np.mean(mask**2.)
als,bells = np.loadtxt(bfile,unpack=True)
imap = enmap.read_map(yfile)
modlmap = mask.modlmap()
bin_edges = np.arange(20,6000,80)
binner = stats.bin2D(modlmap,bin_edges)
kmap = enmap.fft(imap,normalize='phys')/maps.interp(als,bells)(modlmap)*maps.gauss_beam(modlmap,dfwhm)
kmap[~np.isfinite(kmap)] = 0
p2d = (kmap*kmap.conj()).real / w2
cents,p1d = binner.bin(p2d)
io.save_cols(os.environ['WORK']+"/cpower_tilec_%s_%s.txt" % (region,method), (cents,p1d))
else:
cents,p1d = np.loadtxt("cpower_tilec_%s_%s.txt" % (region,method), unpack=True)
pl.add(cents,p1d,color=col,label='This work (%s)' % region_map[region])
if methodp=='sz':
szlab = "SMICA (PR2)"
elif methodp=='nosz':
szlab = "SMICA-nosz (PR3)"
wfilt[ls>500] = 0
wfilt[~np.isfinite(wfilt)] = 0
# Filtered alms
seed = (0,0,0)
t_alm,e_alm,b_alm = solint.get_kmap(ch,seed,lmin,lmax,filtered=True)
# Reconstruction
with bench.show("recon"):
rkalm = qe.filter_alms(solint.get_mv_kappa(polcomb,t_alm,e_alm,b_alm),maps.interp(ls,Als[polcomb]))
hp.write_map(config['data_path']+"mbs_sim_v0.1.0_mv_lensing_map.fits",hp.alm2map(rkalm,nside),overwrite=True)
hp.write_map(config['data_path']+"mbs_sim_v0.1.0_mv_lensing_mask.fits",mask,overwrite=True)
# Filtered reconstruction
fkalm = hp.almxfl(rkalm,wfilt)
frmap = hp.alm2map(fkalm,nside=256)
rmap=hp.alm2map(rkalm,nside=256)
# Input kappa
# TODO: Does this really need to be masked?
ikalm = maps.change_alm_lmax(hp.map2alm(hp.alm2map(get_kappa_alm(0).astype(np.complex128),nside=solint.nside)*solint.mask),2*solint.nside)
# Verify input x cross
w4=np.mean(solint.mask**4)
w3 = np.mean(solint.mask**3) # Mask factors
data_comb=dcomb,
version=None,
sim_index=0)
dmap = enmap.read_map(dfile)
smap = enmap.read_map(sfile)
tmap = enmap.read_map(tfile)
cdmap = enmap.read_map(cdfile)
csmap = enmap.read_map(csfile)
ctmap = enmap.read_map(ctfile)
modlmap = dmap.modlmap()
ls, db = np.loadtxt(dbeam, unpack=True)
dbeam = maps.interp(ls, db)(modlmap)
ls, cdb = np.loadtxt(cdbeam, unpack=True)
cdbeam = maps.interp(ls, cdb)(modlmap)
ls, sb = np.loadtxt(sbeam, unpack=True)
sbeam = maps.interp(ls, sb)(modlmap)
ls, csb = np.loadtxt(csbeam, unpack=True)
csbeam = maps.interp(ls, csb)(modlmap)
#io.hplot(smap,"simmap")
bin_edges = np.arange(20, 6000, 20)
binner = stats.bin2D(modlmap, bin_edges)
p = lambda x: binner.bin((x * x.conj()).real)
def reconvolve(x, ybname, fwhm):
if not (do_reconvolve): return x
ls, bells = np.loadtxt(ybname, unpack=True)
beam_rat = maps.gauss_beam(modlmap, fwhm) / maps.interp(ls, bells)(modlmap)
beam_rat[~np.isfinite(beam_rat)] = 0
return maps.filter_map(x, beam_rat)
conc = 3.2
cc = counts.ClusterCosmology(params,skipCls=True,skipPower=True,skip_growth=True)
z = 0.7
mass = 2e14
thetas = np.geomspace(0.1,10,1000)
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='--')
import numpy as np
import os, sys
import soapack.interfaces as sints
from enlib import bench
from actsims import noise
for season in ['s13', 's14', 's15']:
for apatch in ['boss', 'deep1', 'deep5', 'deep6', 'deep8', 'deep56']:
#for apatch in ['deep1','deep5','deep6','deep8','deep56','boss']:
mask = sints.get_act_mr3_crosslinked_mask(apatch)
ellcen = 5000
ellsig = 1000
modlmap = mask.modlmap()
ells = np.arange(0, modlmap.max())
mfilter = maps.interp(ells,
np.exp(-(ells - ellcen)**2. / 2. /
ellsig**2.))(modlmap)
for array in ['pa1_f150', 'pa2_f150', 'pa3_f150', 'pa3_f090']:
dm = sints.ACTmr3(calibrated=False, region=mask)
fname = "%s_%s_%s" % (season, apatch, array)
try:
splits = dm.get_splits(season=season,
patch=apatch,
arrays=[array],
ncomp=3,
srcfree=False)[0, :, :, ...]
cmap = dm.get_coadd(season=season,
patch=apatch,
array=array,
ncomp=3,
srcfree=False)
for task in my_tasks:
# Load sims
sindex = str(task).zfill(5)
alm = maps.change_alm_lmax(
hp.read_alm(sim_location +
"fullskyLensedUnabberatedCMB_alm_set00_%s.fits" % sindex,
hdu=(1, 2, 3)), mlmax).astype(dtype)
# Add beam deconvolved noise
alm = alm + np.nan_to_num(
qe.almxfl(
cs.rand_alm_healpy(
ps_noise, lmax=mlmax, seed=(100, 200, task), dtype=dtype),
1. / lbeam))
ntt = maps.interp(ells, np.nan_to_num(ps_noise[0, 0] / lbeam**2.))
npp = maps.interp(ells, np.nan_to_num(ps_noise[1, 1] / lbeam**2.))
# Filter
talm_y = qe.filter_alms(alm[0], lambda x: 1. /
(theory.lCl('TT', x) + ntt(x)), args.lmint,
args.lmaxt)
ealm_y = qe.filter_alms(alm[1], lambda x: 1. /
(theory.lCl('EE', x) + npp(x)), args.lminp,
args.lmaxp)
balm_y = qe.filter_alms(alm[2], lambda x: 1. /
(theory.lCl('BB', x) + npp(x)), args.lminp,
args.lmaxp)
# Inputs
ikalm = lensing.phi_to_kappa(
with bench.show("flat sky AL"):
ls,nlkks,theory,qest = lensing.lensing_noise(ells,ntt,nee,nbb, \
ellmin_t,ellmin_t,ellmin_t, \
ellmax_t,ellmax_t,ellmax_t, \
bin_edges, \
camb_theory_file_root=None, \
estimators = ['TT'], \
delens = False, \
theory=theory, \
dimensionless=False, \
unlensed_equals_lensed=True, \
grad_cut=None,width_deg=25.,px_res_arcmin=res)
binner = stats.bin2D(qest.N.modLMap, bin_edges)
cents, albinned = binner.bin(qest.AL['TT'])
Al = maps.interp(cents, albinned)(ells)
Nl = maps.interp(ls, nlkks['TT'])(ells)
lpls, lpal = np.loadtxt("data/nls_2000.txt", unpack=True)
pl = io.Plotter(yscale='log', xscale='log')
pl.add(ells, theory.gCl('kk', ells), lw=3, color='k')
pl.add(ells, Nl, ls="--")
pl.add(lpls, lpal * (lpls * (lpls + 1.))**2. / 4., ls="-.")
#pl._ax.set_ylim(1e-10,1e-6)
pl.done(io.dout_dir + "fullsky_qe_result_al.png")
dh_nls = np.nan_to_num(lpal * (lpls * (lpls + 1.))**2. / 4.)
dh_als = np.nan_to_num(dh_nls * 2. / lpls / (lpls + 1))
Al = dh_als
#### MAKE FULL-SKY LENSED SIMS
def norm_der_cltt(solint, ch, lmin, lmax, uctt_, ucee_, ucte_, ucbb_):
#these are the unperturbed ones
uctt = uctt_
ucee = ucee_
ucte = ucte_
ucbb = ucbb_
#the total goes with the Fs hence are unperturbed
tctt = uctt + maps.interp(ls, nells)(ells)
tcee = ucee + maps.interp(ls, nells_P)(ells)
tcte = ucte
tcbb = ucbb + maps.interp(ls, nells_P)(ells)
#onormfname = opath+"norm_lmin_%d_lmax_%d.txt" % (lmin,lmax)
array1001 = perturbe_clist(uctt, lprime, 1.01)
array999 = perturbe_clist(uctt, lprime, 0.99)
N1001 = [[], [], [], [], []] #list of lists containing tt,ee,eb,te,tb
N0999 = [[], [], [], [], []]
for i in range(len(array1001)):
print(i)
als, aAls, aal_mv_pol, aal_mv, aAl_te_hdv = qe.symlens_norm(
array1001[i],
tctt,
ucee,
tcee,
ucte,
tcte,
ucbb,
tcbb,
lmin=lmin,
lmax=lmax,
plot=False)
bls, bAls, bal_mv_pol, bal_mv, bAl_te_hdv = qe.symlens_norm(
array999[i],
tctt,
ucee,
tcee,
ucte,
tcte,
ucbb,
tcbb,
lmin=lmin,
lmax=lmax,
plot=False)
N1001[0].append(aAls['TT'])
N0999[0].append(bAls['TT'])
N1001[1].append(aAls['EE'])
N0999[1].append(bAls['EE'])
N1001[2].append(aAls['EB'])
N0999[2].append(bAls['EB'])
N1001[3].append(aAls['TE'])
N0999[3].append(bAls['TE'])
N1001[4].append(aAls['TB'])
N0999[4].append(bAls['TB'])
delta = diff_cl(uctt, lprime)
keys = ['TT', 'EE', 'EB', 'TE', 'TB']
for k in range(len(keys)):
diff = [als]
for i in range(len(N1001[1])):
der = ((N1001[k][i] - N0999[k][i])) / delta[i]
diff.append(der)
np.savetxt(
'/global/homes/j/jia_qu/so-lenspipe/data/n0{}_cltt.txt'.format(
keys[k]), der)
np.savetxt('../data/n0{}_cltt.txt'.format(keys[k]), diff)
cmb_dir = p['data_dir']
fells,ftt = np.loadtxt('../data/fg.dat',usecols=[0,1],unpack=True)
ftt = ftt/fells/(fells+1.)*2.*np.pi
fnames = [f'{cmb_dir}/fullskyLensedUnabberatedCMB_alm_cmbset00_phiset00_00000.fits',f'{cmb_dir}/../../alex/v0.4/fullskyLensedUnabberatedCMB_alm_set00_00000.fits']
versions = ['v0.5','v0.4']
pl = io.Plotter('rCell',ylabel='$(C_L-C^{\\rm theory}_L) / (C^{\\rm theory}_L + C^{\\rm fg}_L)$')
pl2 = io.Plotter('Dell')
theory = cosmology.default_theory()
ls = np.arange(10000)
ftt = maps.interp(fells,ftt)(ls)
cltt = theory.lCl('TT',ls)
for i,fname in enumerate(fnames):
alm = hp.read_alm(fname).astype(np.complex128)
cls = hp.alm2cl(alm)
cls = maps.interp(np.arange(cls.size),cls)(ls)
pl._ax.scatter(ls,(cls-cltt)/(cltt+ftt),s=1)
pl.add([],[],label=versions[i])
pl2.add(ls,cls,label=versions[i])
pl._ax.set_ylim(-0.02,0.02)
pl.hline(y=0)
pl._ax.set_xlim(0,10000)
pl.legend(loc='upper right')
cltt = theory.lCl('TT', ells)
mgen = maps.MapGen(shape, wcs, cltt[None, None])
noise = [10, 20]
ngen1 = maps.MapGen(shape, wcs,
(ells * 0 + (noise[0] * np.pi / 180. / 60.)**2.)[None,
None])
ngen2 = maps.MapGen(shape, wcs,
(ells * 0 + (noise[1] * np.pi / 180. / 60.)**2.)[None,
None])
cov = enmap.enmap(np.zeros((shape[0], shape[1], 2, 2)), wcs)
for i in range(2):
for j in range(2):
cov[..., i, j] = maps.interp(
ells,
cltt)(modlmap) + int(i == j) * (noise[i] * np.pi / 180. / 60.)**2.
cinv = np.linalg.inv(cov)
nsims = 30
np.random.seed(1)
bin_edges = np.arange(80, 3000, 40)
binner = stats.bin2D(modlmap, bin_edges)
s = stats.Stats()
gellmax = modlmap.max()
ells = np.arange(0, gellmax, 1)
ctheory = ilc.CTheory(ells)
# load theory
camb_root = "data/cosmo2017_10K_acc3"
theory = cosmology.loadTheorySpectraFromCAMB(camb_root,get_dimensionless=False)
# ells corresponding to modes in the alms
nside = 2048
ells = np.arange(0,3*nside+1,1)
#lpls,lpal = np.loadtxt("data/nls_%d.txt" % lmax,unpack=True)
lpfile = "/gpfs01/astro/workarea/msyriac/data/sims/msyriac/lenspix/cosmo2017_lmax_fix_lens_lmax_%d_qest_lmax_%d_AL.txt" % (lmax+2000,lmax)
lpls,lpal = np.loadtxt(lpfile,unpack=True,usecols=[0,1])
lpal = lpal / (lpls) / (lpls+1.)
dh_nls = np.nan_to_num(lpal*(lpls*(lpls+1.))**2./4.)
dh_als = np.nan_to_num(dh_nls * 2. / lpls /(lpls+1))
Al = maps.interp(lpls,dh_als)(ells)
sim_location = "/gpfs01/astro/workarea/msyriac/data/sims/msyriac/lenspix/"
ksim_location = "/gpfs01/astro/workarea/msyriac/data/sims/msyriac/lenspix/"
#bin_edges = np.linspace(2,lmax,300)
bin_edges = np.logspace(np.log10(2),np.log10(lmax),100)
binner = stats.bin1D(bin_edges)
mstats = stats.Stats(comm)
lstr = ""
if lmax==2000: lstr = "_lmax2250"
from pixell import enmap
import numpy as np
import os, sys
mask = enmap.read_map(
"/scratch/r/rbond/msyriac/data/depot/tilec/map_v1.0.0_rc_joint_deep56/tilec_mask.fits"
)
modlmap = mask.modlmap()
smap = enmap.read_map(
"/scratch/r/rbond/msyriac/data/depot/tilec/map_v1.0.0_rc_joint_deep56/tilec_single_tile_deep56_cmb_map_v1.0.0_rc_joint.fits"
)
l, b = np.loadtxt(
"/scratch/r/rbond/msyriac/data/depot/tilec/map_v1.0.0_rc_joint_deep56/tilec_single_tile_deep56_cmb_map_v1.0.0_rc_joint_beam.txt",
unpack=True)
sbeam = maps.interp(l, b)(modlmap)
cmap = enmap.read_map(
"/scratch/r/rbond/msyriac/data/depot/tilec/map_v1.0.0_rc_joint_deep56/tilec_single_tile_deep56_cmb_deprojects_comptony_map_v1.0.0_rc_joint.fits"
)
l, b = np.loadtxt(
"/scratch/r/rbond/msyriac/data/depot/tilec/map_v1.0.0_rc_joint_deep56/tilec_single_tile_deep56_cmb_deprojects_comptony_map_v1.0.0_rc_joint_beam.txt",
unpack=True)
cbeam = maps.interp(l, b)(modlmap)
nsmap = enmap.read_map(
"/scratch/r/rbond/msyriac/data/depot/tilec/map_v1.0.0_rc_joint_deep56/tilec_single_tile_deep56_cmb_map_v1.0.0_rc_joint_noise.fits"
)
ncmap = enmap.read_map(
"/scratch/r/rbond/msyriac/data/depot/tilec/map_v1.0.0_rc_joint_deep56/tilec_single_tile_deep56_cmb_deprojects_comptony_map_v1.0.0_rc_joint_noise.fits"
)
crossnoise = enmap.read_map(
"/scratch/r/rbond/msyriac/data/depot/tilec/map_v1.0.0_rc_joint_deep56/tilec_single_tile_deep56_cmb_deprojects_comptony_map_v1.0.0_rc_joint_cross_noise.fits"
except:
totinputs[input_name] = res.copy()
iis[input_name] = res
for solution in args.solutions.split(','):
comps = "tilec_single_tile_" + region + "_"
comps = comps + name_map[components[solution][0]] + "_"
if len(components[solution]) > 1:
comps = comps + "deprojects_" + '_'.join(
[name_map[x] for x in components[solution][1:]]) + "_"
comps = comps + version
fname = "%s/%s.fits" % (savedir, comps)
imap = enmap.read_map(fname)
ls, bells = np.loadtxt("%s/%s_beam.txt" % (savedir, comps),
unpack=True)
kbeam = maps.interp(ls, bells)(modlmap)
# rbeam = maps.gauss_beam(imap.modlmap(),10.)/kbeam
# rbeam[~np.isfinite(rbeam)]=0
# if task==0: io.hplot(maps.filter_map(imap,rbeam),"/scratch/r/rbond/msyriac/cmap")# !!!
# sys.exit()
with np.errstate(divide='ignore', invalid='ignore'):
kmap = enmap.fft(imap, normalize='phys') / kbeam
kmap[~np.isfinite(kmap)] = 0
res = binner.bin(np.real(kmap * kmap.conj()))[1] / w2
try:
totautos[solution] = totautos[solution] + res
except:
totautos[solution] = res.copy()
input_name = components[solution][0]
def get_ilc_noise(ells):
cents, sn1d, cn1d, scn1d, _, _ = np.loadtxt("lnoises.txt", unpack=True)
return maps.interp(cents, sn1d)(ells), maps.interp(
cents, cn1d)(ells), maps.interp(cents, scn1d)(ells)
for task in my_tasks:
# Choose a seed. This has to be varied when simulating.
seed = (0,0,task+sindex)
# If debugging, get unfiltered maps and plot Cls
if task==0 and debug_cmb:
t_alm,e_alm,b_alm = solint.get_kmap(channel,seed,lmin,lmax,filtered=False)
tcl = hp.alm2cl(t_alm)
ls = np.arange(tcl.size)
pl = io.Plotter('Cell')
pl.add(ls,tcl/w2)
ls2,nells,nells_P = solint.get_noise_power(channel,beam_deconv=True)
theory = cosmology.default_theory()
pl.add(ls,theory.lCl('TT',ls) + maps.interp(ls2,nells)(ls),color='k')
pl._ax.set_xlim(1,6000)
pl._ax.set_ylim(1e-6,1e3)
pl.done(f'{solenspipe.opath}/tcl.png')
imap = enmap.downgrade(solint.alm2map(np.asarray([t_alm,e_alm,b_alm]),ncomp=3) * maps.binary_mask(mask),2)
for i in range(3): io.hplot(imap[i],f'{solenspipe.opath}/imap_{i}',mask=0)
with bench.show("sim"):
# Get simulated, prepared filtered T, E, B maps, i.e. (1/(C+N) * teb_alm)
t_alm,e_alm,b_alm = solint.get_kmap(channel,seed,lmin,lmax,filtered=True)
# Get the reconstructed kappa map alms and filter it with the normalization
recon_alms = qe.filter_alms(solint.get_mv_kappa(polcomb,t_alm,e_alm,b_alm),maps.interp(Als['L'],Als[polcomb]))
# Subtract a meanfield if necessary
recon_alms = recon_alms - mf_alm
pl.done("band_%s.png" % qid)
if gauss_beam:
if 'p' in qid:
fwhm = dm.fwhms[array]
else:
fwhm = 1.4 * (150./cfreq)
lbeam = maps.gauss_beam(ells,fwhm)
else:
lbeam = tutils.get_kbeam(qid,ells,sanitize=False,planck_pixwin=False)
with bench.show("beamint"):
fbnus = maps.interp(ells,lbeam[None,:],fill_value=(lbeam[0],lbeam[-1]))
bnus = fbnus((cfreq/nu_ghz)*ells[:,None])[0].swapaxes(0,1)
bnus = bnus / bnus[:,:1]
pl = io.Plotter(xlabel='l',ylabel='b')
for i in range(bnus.shape[0]):
if trans[i]>1e-1: pl.add(ells,bnus[i]/lbeam)
pl.hline(y=1)
pl._ax.set_ylim(0.8,1.2)
pl.done("abeams_%s.png" % qid)
