def __init__(self, ellmin, ellmax, nlev_t, beam_arcmin, px_arcmin, width_deg, cmb1=None, cmb2=None, inkap=None): self.cmb1 = cmb1 self.cmb2 = cmb2 self.inkap = inkap self.ellmin = ellmin self.ellmax = ellmax self.nlev_t = nlev_t self.beam_arcmin = beam_arcmin self.px_arcmin = px_arcmin self.width_deg = width_deg self.shape = self.cmb1.shape self.wcs = self.cmb2.wcs # npix x npix cutouts self.npix = int(width_deg * 60 / self.px_arcmin) # total number of tiles self.ntiles = int(np.prod(self.shape) / self.npix**2) # number of tiles in a row self.num_x = int(360 / self.width_deg) # Get Cl_TT in theory for symlens, it is same for each cutout self.theory = cosmology.default_theory()
def plot(cents, nls, ncoadd, pols, tag="default"): npols = len(pols) pl = io.Plotter(xyscale='linlog', ylabel='$C_L$', xlabel='$L$') for i in range(npols): for j in range(i, npols): nl1d = nls[i, j] if i != j: pl.add(cents, np.abs(nl1d), ls="--", alpha=0.2) #,label=pols[i]+'x'+pols[j] else: pl.add(cents, nl1d, alpha=0.6) #,label=pols[i]) ells = np.arange(0, 2500, 1) theory = cosmology.default_theory() clkk = theory.gCl('kk', ells) pl.add(ells, clkk, color='k', lw=3) pl.legend(loc='upper right') pl._ax.set_ylim(1e-10, 1e-4) pl.add(cents, ncoadd, color='red', lw=3) #,label='MV') pl.done("nlkk_%s.png" % tag) # pl = io.Plotter(xyscale='linlin') # pl.add(cents,nls[0,3],label="TT x EB") # pl.hline(y=0) # pl.done("nltteb_%s.png"%tag) io.save_cols("lensing_noise_%s.txt" % tag, (cents, ncoadd))
def get_cmb(ells): theory = cosmology.default_theory() lcltt = theory.lCl('TT', ells) lclee = theory.lCl('EE', ells) lclte = theory.lCl('TE', ells) lclbb = theory.lCl('BB', ells) clkk = theory.gCl('kk', ells) return lcltt, lclee, lclte, lclbb, clkk
def test_limber(): zs = np.geomspace(0.1,10.,40) ks = np.geomspace(1e-4,10,100) ms = np.geomspace(1e8,1e16,30) hcos = hmvec.HaloModel(zs,ks,ms,nfw_numeric=False) pmm_1h = hcos.get_power_1halo(name="nfw") pmm_2h = hcos.get_power_2halo(name="nfw") Wk = hcos.lensing_window(zs,zs=1100.) Pmm = pmm_1h + pmm_2h ells = np.linspace(100,1000,20) ckk = hcos.C_kk(ells,zs,ks,Pmm,lwindow1=Wk,lwindow2=Wk) theory = cosmology.default_theory() pl = io.Plotter(xyscale='linlog') pl.add(ells,ckk) pl.add(ells,theory.gCl('kk',ells),ls='--') pl.done('ckk_comp.png') bias = 2. nzs = np.exp(-(zs-1.0)**2./0.3**2.) ckg = hcos.C_kg(ells,zs,ks,Pmm*bias,lwindow=Wk,gzs=zs,gdndz=nzs) cgg = hcos.C_gg(ells,zs,ks,Pmm*bias**2,gzs=zs,gdndz=nzs) lc = cosmology.LimberCosmology(skipCls=True,low_acc=True) lc.addNz('g',zs,nzs,bias=bias) lc.generateCls(ells) ckg2 = lc.getCl('cmb','g') cgg2 = lc.getCl('g','g') pl = io.Plotter(xyscale='linlog') pl.add(ells,ckg) pl.add(ells,ckg2,ls='--') pl.done('ckg_comp.png') pl = io.Plotter(xyscale='linlog') pl.add(ells,cgg) pl.add(ells,cgg2,ls='--') pl.done('cgg_comp.png')
def test_lensing(): zs = np.geomspace(0.1, 300., 30) ks = np.geomspace(1e-4, 20, 100) ms = np.geomspace(1e10, 1e17, 20) hcos = hmvec.HaloModel(zs, ks, ms, nfw_numeric=False) pmm_1h = hcos.get_power_1halo(name="nfw") pmm_2h = hcos.get_power_2halo(name="nfw") Wk = hcos.lensing_window(zs, zs=1100.) pl = io.Plotter(xyscale='loglin') pl.add(zs, Wk) pl.done() Pmm = pmm_1h + pmm_2h ells = np.linspace(100, 1000, 20) ckk = hcos.C_kk(ells, zs, ks, Pmm, lwindow1=Wk, lwindow2=Wk) theory = cosmology.default_theory() pl = io.Plotter(xyscale='linlog') pl.add(ells, ckk) pl.add(ells, theory.gCl('kk', ells), ls='--') pl.done()
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
def build_empirical_cov(kdiffs, kcoadds, wins, mask, lmins, lmaxs, anisotropic_pairs, do_radial_fit, save_fn, signal_bin_width=None, signal_interp_order=0, delta_ell=400, rfit_lmaxes=None, rfit_wnoise_width=250, rfit_lmin=300, rfit_bin_width=None, verbose=True, debug_plots_loc=None, separate_masks=False): """ TODO: Add docs for wins and mask, and names and save_fn Build an empirical covariance matrix using hybrid radial (signal) and cartesian (noise) binning. Args: kdiffs: list of length narrays of (nsplits,Ny,Nx) fourier transforms of maps that have already been inverse noise weighted and tapered. This routine will not apply any corrections for the windowing. Alternatively, list of strings containing filenames to versions of these on disk. kcoadds: list of length narrays of (Ny,Nx) fourier transforms of coadd maps that have already been inverse noise weighted and tapered. This routine will not apply any corrections for the windowing. Alternatively, list of strings containing filenames to versions of these on disk. anisotropic_pairs: list of 2-tuples specifying which elements of the covariance matrix will be treated under hybrid radial(signal)/cartesian(noise) mode. If (i,j) is in the list, (j,i) will be added if it already doesn't exist, since the covariance has to be symmetric. For these pairs, an atmospheric 1/f noise will be fitted out before downsampling the noise power. For each pair of arrays, one of the following modes is chosen: 1) fully radial - this is appropriate for any i,j for an isotropic experiment like Planck or for i!=j combinations of independent experiments like ACT/Planck or for i!=j combinations of ACT arrays that have independent instrument noise (no correlated atmosphere), e.g. pa2,pa3 - it is calculated simply by radially binning the total spectrum of the coadds ps(i,j). The split info is not used. 2) hybrid radial/cartesian - this is appropriate for diagonals i=j of a ground-based experiment like ACT, or for i!=j combinations of ACT arrays that have correlated atmosphere e.g. pa3-150/pa3-90 - this routine assumes that such off diagonal pairs of arrays have the same number of splits, and calculates the noise power from splits, and the signal from the total spectrum minus the noise power. """ # Setup narrays = len(kdiffs) on_disk = False try: tshape = kdiffs[0].shape[-2:] except: assert isinstance( kdiffs[0], basestring), "List contents are neither enmaps nor filenames." on_disk = True def get_mask(aind): if separate_masks: return _load_map(mask[aind]) else: assert mask.ndim == 2 return mask mask = get_mask(0) shape, wcs = mask.shape[-2:], mask.wcs def _load_map(kitem): if not (on_disk): return kitem else: if kitem[:-5] == '.fits': return enmap.read_map(kitem) elif kitem[:-4] == '.npy': return enmap.enmap(np.load(kitem), wcs) else: raise IOError minell = maps.minimum_ell(shape, wcs) modlmap = enmap.modlmap(shape, wcs) # Defaults if rfit_lmaxes is None: px_arcmin = np.rad2deg(maps.resolution(shape, wcs)) * 60. rfit_lmaxes = [8000 * 0.5 / px_arcmin] * narrays if rfit_bin_width is None: rfit_bin_width = minell * 4. if signal_bin_width is None: signal_bin_width = minell * 8. maxval = -np.inf # Loop over unique covmat elements for aindex1 in range(narrays): for aindex2 in range(aindex1, narrays): # !!!!! # from orphics import cosmology # theory = cosmology.default_theory() # # #['p01','p02','p03','p04','p05','p06','p07','p08'] # # freqs = [30,44,70,100,143,217,353,545] # # fwhms = [7*143/freq for freq in freqs] # # rmss = [195,226,199,77,33,47,153,1000] # # fwhm1 = fwhms[aindex1] # # fwhm2 = fwhms[aindex2] # rms = 0 if aindex1!=aindex2 else 60 #rmss[aindex1] # fwhm1 = fwhm2 = 1.5 # tcov = theory.lCl('TT',modlmap)*maps.gauss_beam(modlmap,fwhm1)*maps.gauss_beam(modlmap,fwhm2) + rms # !!!! # save_fn(tcov,aindex1,aindex2) # continue # !!! if verbose: print("Calculating covariance for array ", aindex1, " x ", aindex2, " ...") hybrid = ((aindex1, aindex2) in anisotropic_pairs) or ( (aindex2, aindex1) in anisotropic_pairs) kd1 = _load_map(kdiffs[aindex1]) kd2 = _load_map(kdiffs[aindex2]) nsplits1 = kd1.shape[0] nsplits2 = kd2.shape[0] assert (nsplits1 == 2 or nsplits1 == 4) and (nsplits2 == 2 or nsplits2 == 4) kc1 = _load_map(kcoadds[aindex1]) kc2 = _load_map(kcoadds[aindex2]) if kc1.ndim > 2: assert kc1.shape[0] == 1 kc1 = kc1[0] if kc2.ndim > 2: assert kc2.shape[0] == 1 kc2 = kc2[0] m1 = get_mask(aindex1) m2 = get_mask(aindex2) if hybrid: w1 = _load_map(wins[aindex1]) w2 = _load_map(wins[aindex2]) ncov = simnoise.noise_power(kd1, m1, kmaps2=kd2, weights2=m2, coadd_estimator=True) ccov = np.real(kc1 * kc2.conj()) / np.mean(m1 * m2) scov = ccov - ncov from orphics import cosmology theory = cosmology.default_theory() # # #['p01','p02','p03','p04','p05','p06','p07','p08'] # # freqs = [30,44,70,100,143,217,353,545] # # fwhms = [7*143/freq for freq in freqs] # # rmss = [195,226,199,77,33,47,153,1000] # # fwhm1 = fwhms[aindex1] # # fwhm2 = fwhms[aindex2] # rms = 0 if aindex1!=aindex2 else 60 #rmss[aindex1] fwhm1 = fwhm2 = 1.5 scov = theory.lCl('TT', modlmap) * maps.gauss_beam( modlmap, fwhm1) * maps.gauss_beam(modlmap, fwhm2) # save_fn(tcov,aindex1,aindex2) # import os # # newcov = np.real(kd1[aindex1][0]*ksplits[aindex2][1].conj())/np.mean(w1*w2*m1*m2) # enmap.write_map(os.environ['WORK']+'/tiling/ncov.fits',ncov) # enmap.write_map(os.environ['WORK']+'/tiling/ccov.fits',ccov) # enmap.write_map(os.environ['WORK']+'/tiling/scov.fits',scov) # sys.exit() else: scov = np.real(kc1 * kc2.conj()) / np.mean(m1 * m2) ncov = None dscov = covtools.signal_average( scov, bin_width=signal_bin_width, kind=signal_interp_order, lmin=max(lmins[aindex1], lmins[aindex2]), dlspace=True ) # ((a,inf),(inf,inf)) doesn't allow the first element to be used, so allow for cross-covariance from non informative if ncov is not None: assert nsplits1 == nsplits2 nsplits = nsplits1 dncov, _, _ = covtools.noise_block_average( ncov, nsplits=nsplits, delta_ell=delta_ell, radial_fit=do_radial_fit[aindex1], lmax=max(rfit_lmaxes[aindex1], rfit_lmaxes[aindex2]), wnoise_annulus=rfit_wnoise_width, lmin=rfit_lmin, bin_annulus=rfit_bin_width, fill_lmax=max(lmaxs[aindex1], lmaxs[aindex2]), log=(aindex1 == aindex2)) else: dncov = np.zeros(dscov.shape) tcov = dscov + dncov assert np.all(np.isfinite(tcov)) # print(modlmap[np.isinf(tcov)]) if aindex1 == aindex2: tcov[modlmap <= lmins[aindex1]] = 1e90 tcov[modlmap >= lmaxs[aindex1]] = 1e90 # try: # print("scov : ",scov[4,959],scov[5,959]) # except: pass # try: # print("ncov : ",ncov[4,959],ncov[5,959]) # except: # pass # print("dscov : ",dscov[4,959],dscov[5,959]) # print("dncov : ",dncov[4,959],dncov[5,959]) maxcov = tcov.max() if maxcov > maxval: maxval = maxcov if np.any(np.isnan(tcov)): raise ValueError # save PS save_fn(tcov, aindex1, aindex2) if debug_plots_loc: save_debug_plots(scov, dscov, ncov, dncov, tcov, modlmap, aindex1, aindex2, save_loc=debug_plots_loc) return maxval
from __future__ import print_function from orphics import maps, io, cosmology, symcoupling as sc, stats, lensing from enlib import enmap, bench import numpy as np import os, sys cache = True hdv = False deg = 5 px = 1.5 shape, wcs = maps.rect_geometry(width_deg=deg, px_res_arcmin=px) mc = sc.LensingModeCoupling(shape, wcs) pols = ['TT', "TE", 'EE', 'EB', 'TB'] theory = cosmology.default_theory(lpad=20000) 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)
def test_pol(): from orphics import lensing, io, cosmology, maps est = "hu_ok" pols = ['TT', 'EE', 'TE', 'EB', 'TB'] # est = "hdv" # pols = ['TT','EE','TE','ET','EB','TB'] deg = 5. px = 2.0 tellmin = 30 tellmax = 3000 pellmin = 30 pellmax = 5000 kellmin = 10 kellmax = 5000 bin_width = 40 beam_arcmin = 1.5 noise_uk_arcmin = 10.0 theory = cosmology.default_theory(lpad=30000) shape, wcs = s.rect_geometry(width_deg=deg, px_res_arcmin=px) modlmap = enmap.modlmap(shape, wcs) kbeam = s.gauss_beam(modlmap, beam_arcmin) n2d = (noise_uk_arcmin * np.pi / 180. / 60.)**2. / kbeam**2. tmask = s.mask_kspace(shape, wcs, lmin=tellmin, lmax=tellmax) pmask = s.mask_kspace(shape, wcs, lmin=pellmin, lmax=pellmax) kmask = s.mask_kspace(shape, wcs, lmin=kellmin, lmax=kellmax) bin_edges = np.arange(kellmin, kellmax, bin_width) binner = s.bin2D(modlmap, bin_edges) feed_dict = {} cltt = theory.lCl('TT', modlmap) clee = theory.lCl('EE', modlmap) clbb = theory.lCl('BB', modlmap) clte = theory.lCl('TE', modlmap) feed_dict['uC_T_T'] = cltt feed_dict['tC_T_T'] = (cltt + n2d) feed_dict['uC_E_E'] = clee feed_dict['tC_E_E'] = (clee + n2d * 2.) feed_dict['uC_B_B'] = clbb feed_dict['tC_B_B'] = (clbb + n2d * 2.) feed_dict['uC_T_E'] = clte feed_dict['tC_T_E'] = clte ells = np.arange(0, 10000, 1) pl = io.Plotter(xyscale='loglog') pl.add(ells, theory.gCl('kk', ells)) imask = {'T': tmask, 'E': pmask, 'B': pmask} for pol in pols: print(pol) X, Y = pol cents, Nl = binner.bin( s.N_l(shape, wcs, feed_dict, est, pol, xmask=imask[X], ymask=imask[Y])) pl.add(cents, Nl, label=pol) pl._ax.set_xlim(10, kellmax) pl.done("nls.png")
def test_shear(): from orphics import lensing, io, cosmology, maps deg = 20. px = 2.0 tellmin = 30 tellmax = 3500 kellmin = 10 kellmax = 3000 bin_width = 20 beam_arcmin = 1.4 noise_uk_arcmin = 7.0 theory = cosmology.default_theory(lpad=30000) shape, wcs = s.rect_geometry(width_deg=deg, px_res_arcmin=px) flsims = lensing.FlatLensingSims(shape, wcs, theory, beam_arcmin, noise_uk_arcmin) kbeam = flsims.kbeam modlmap = enmap.modlmap(shape, wcs) fc = maps.FourierCalc(shape, wcs) n2d = (noise_uk_arcmin * np.pi / 180. / 60.)**2. / flsims.kbeam**2. tmask = s.mask_kspace(shape, wcs, lmin=tellmin, lmax=tellmax) kmask = s.mask_kspace(shape, wcs, lmin=kellmin, lmax=kellmax) bin_edges = np.arange(kellmin, kellmax, bin_width) binner = s.bin2D(modlmap, bin_edges) i = 0 unlensed, kappa, lensed, beamed, noise_map, observed = flsims.get_sim( seed_cmb=(i, 1), seed_kappa=(i, 2), seed_noise=(i, 3), lens_order=5, return_intermediate=True) _, kmap, _ = fc.power2d(observed) pii2d, kinput, _ = fc.power2d(kappa) feed_dict = {} cltt = theory.lCl('TT', modlmap) feed_dict['uC_T_T'] = theory.lCl('TT', modlmap) feed_dict['tC_T_T'] = (cltt + n2d) feed_dict['X'] = kmap / kbeam feed_dict['Y'] = kmap / kbeam ells = np.arange(0, 10000, 1) ucltt = theory.lCl('TT', ells) feed_dict['duC_T_T'] = s.interp(ells, np.gradient(np.log(ucltt), np.log(ells)))(modlmap) sAl = s.A_l(shape, wcs, feed_dict, "shear", "TT", xmask=tmask, ymask=tmask) sNl = s.N_l(shape, wcs, feed_dict, "shear", "TT", xmask=tmask, ymask=tmask, Al=sAl) sukappa = s.unnormalized_quadratic_estimator(shape, wcs, feed_dict, "shear", "TT", xmask=tmask, ymask=tmask) snkappa = sAl * sukappa pir2d3 = fc.f2power(snkappa, kinput) cents, pir1d3 = binner.bin(pir2d3) cents, pii1d = binner.bin(pii2d) cents, prr1d = binner.bin(fc.f2power(snkappa, snkappa)) cents, Nlkk3 = binner.bin(sNl) pl = io.Plotter(xyscale='loglog') pl.add(ells, theory.gCl('kk', ells)) pl.add(cents, pii1d, color='k', lw=3) pl.add(cents, pir1d3, label='shear') pl.add(cents, prr1d) pl.add(cents, Nlkk3, ls=":") pl._ax.set_xlim(10, 3500) pl.done("ncomp.png")
def test_hdv_huok_planck(): from orphics import lensing, io, cosmology, maps shape, wcs = enmap.geometry(shape=(512, 512), res=2.0 * putils.arcmin, pos=(0, 0)) modlmap = enmap.modlmap(shape, wcs) theory = cosmology.default_theory() ells = np.arange(0, 3000, 1) ctt = theory.lCl('TT', ells) # ps,_ = powspec.read_camb_scalar("tests/Aug6_highAcc_CDM_scalCls.dat") # ells = range(ps.shape[-1]) ## Build HuOk TT estimator f = s.Ldl1 * s.e('uC_T_T_l1') + s.Ldl2 * s.e('uC_T_T_l2') F = f / 2 / s.e('tC_T_T_l1') / s.e('tC_T_T_l2') expr1 = f * F feed_dict = {} feed_dict['uC_T_T'] = s.interp(ells, ctt)(modlmap) feed_dict['tC_T_T'] = s.interp(ells, ctt)(modlmap) + ( 33. * np.pi / 180. / 60.)**2. / s.gauss_beam(modlmap, 7.0)**2. tellmin = 10 tellmax = 3000 xmask = s.mask_kspace(shape, wcs, lmin=tellmin, lmax=tellmax) integral = s.integrate(shape, wcs, feed_dict, expr1, xmask=xmask, ymask=xmask).real Nl = modlmap**4. / integral / 4. bin_edges = np.arange(10, 3000, 40) binner = s.bin2D(modlmap, bin_edges) cents, nl1d = binner.bin(Nl) ## Build HDV TT estimator F = s.Ldl1 * s.e('uC_T_T_l1') / s.e('tC_T_T_l1') / s.e('tC_T_T_l2') expr1 = f * F integral = s.integrate(shape, wcs, feed_dict, expr1, xmask=xmask, ymask=xmask).real Nl = modlmap**4. / integral / 4. cents, nl1d2 = binner.bin(Nl) cents, nl1d3 = binner.bin( s.N_l_cross(shape, wcs, feed_dict, "hu_ok", "TT", "hu_ok", "TT", xmask=xmask, ymask=xmask)) cents, nl1d4 = binner.bin( s.N_l_cross(shape, wcs, feed_dict, "hdv", "TT", "hdv", "TT", xmask=xmask, ymask=xmask)) cents, nl1d5 = binner.bin( s.N_l(shape, wcs, feed_dict, "hu_ok", "TT", xmask=xmask, ymask=xmask)) cents, nl1d6 = binner.bin( s.N_l(shape, wcs, feed_dict, "hdv", "TT", xmask=xmask, ymask=xmask)) clkk = theory.gCl('kk', ells) pl = io.Plotter(xyscale='linlog') pl.add(cents, nl1d) pl.add(cents, nl1d2) # pl.add(cents,nl1d3) pl.add(cents, nl1d4) pl.add(cents, nl1d5) pl.add(cents, nl1d6) pl.add(ells, clkk) pl.done("plcomp.png")
def test_lens_recon(): from orphics import lensing, io, cosmology, maps from enlib import bench deg = 10. px = 2.0 tellmin = 100 tellmax = 3000 kellmin = 40 kellmax = 3000 grad_cut = None bin_width = 80 beam_arcmin = 0.01 noise_uk_arcmin = 0.01 theory = cosmology.default_theory(lpad=30000) shape, wcs = s.rect_geometry(width_deg=deg, px_res_arcmin=px) flsims = lensing.FlatLensingSims(shape, wcs, theory, beam_arcmin, noise_uk_arcmin) kbeam = flsims.kbeam modlmap = enmap.modlmap(shape, wcs) fc = maps.FourierCalc(shape, wcs) n2d = (noise_uk_arcmin * np.pi / 180. / 60.)**2. / flsims.kbeam**2. tmask = s.mask_kspace(shape, wcs, lmin=tellmin, lmax=tellmax) kmask = s.mask_kspace(shape, wcs, lmin=kellmin, lmax=kellmax) with bench.show("orphics init"): qest = lensing.qest(shape, wcs, theory, noise2d=n2d, kmask=tmask, kmask_K=kmask, pol=False, grad_cut=grad_cut, unlensed_equals_lensed=True, bigell=30000) bin_edges = np.arange(kellmin, kellmax, bin_width) binner = s.bin2D(modlmap, bin_edges) i = 0 unlensed, kappa, lensed, beamed, noise_map, observed = flsims.get_sim( seed_cmb=(i, 1), seed_kappa=(i, 2), seed_noise=(i, 3), lens_order=5, return_intermediate=True) kmap = enmap.fft(observed, normalize="phys") # _,kmap,_ = fc.power2d(observed) with bench.show("orphics"): kkappa = qest.kappa_from_map("TT", kmap / kbeam, alreadyFTed=True, returnFt=True) pir2d, kinput = fc.f1power(kappa, kkappa) pii2d = fc.f2power(kinput, kinput) prr2d = fc.f2power(kkappa, kkappa) cents, pir1d = binner.bin(pir2d) cents, pii1d = binner.bin(pii2d) cents, prr1d = binner.bin(prr2d) feed_dict = {} cltt = theory.lCl('TT', modlmap) feed_dict['uC_T_T'] = theory.lCl('TT', modlmap) feed_dict['tC_T_T'] = cltt + n2d feed_dict['X'] = kmap / kbeam feed_dict['Y'] = kmap / kbeam with bench.show("symlens init"): Al = s.A_l(shape, wcs, feed_dict, "hdv", "TT", xmask=tmask, ymask=tmask) Nl = s.N_l_from_A_l_optimal(shape, wcs, Al) with bench.show("symlens"): ukappa = s.unnormalized_quadratic_estimator(shape, wcs, feed_dict, "hdv", "TT", xmask=tmask, ymask=tmask) nkappa = Al * ukappa pir2d2 = fc.f2power(nkappa, kinput) cents, pir1d2 = binner.bin(pir2d2) cents, Nlkk = binner.bin(qest.N.Nlkk['TT']) cents, Nlkk2 = binner.bin(Nl) pl = io.Plotter(xyscale='linlog') pl.add(cents, pii1d, color='k', lw=3) pl.add(cents, pir1d, label='orphics') pl.add(cents, pir1d2, label='hdv symlens') pl.add(cents, Nlkk, ls="--", label='orphics') pl.add(cents, Nlkk2, ls="-.", label='symlens') pl.done("ncomp.png")
"/new_mr3f/coadd_srcfree_filtered_%s" % fname, grid=True) rmap = maps.filter_map(splits * mask, mfilter) io.hplot(rmap, os.environ['WORK'] + "/new_mr3f/splits_srcfree_filtered_%s" % fname, grid=True) sys.exit() out_dir = "/scratch/r/rbond/msyriac/data/depot/actsims/inpainted/" plot_img = lambda x, y, **kwargs: io.plot_img( x, os.environ['WORK'] + "/new_mr3f/" + y, cmap='gray', **kwargs) noise_pix = 60 cmb_theory_fn = lambda s, l: cosmology.default_theory().lCl(s, l) hole_radius = 9. res = np.deg2rad(0.5 / 60.) def plot_cutout(nsplits, cutout, pcutout, ivars, tag="", skip_plots=False): pols = ['I', 'Q', 'U'] retvars = ivars.copy() for s in range(nsplits): if np.std(cutout[s]) < 1e-3: print("Skipping split %d as it seems empty" % s) continue iname = "%s%s_%s_%s_split_%d_%d" % (tag, season, patch, array, s, sid) if not (skip_plots): plot_img(ivars[s, 0], "ivars_%s.png" % iname) for p in range(3): pol = pols[p]
def inpaint_map_white(imap,ivar,fn_beam,union_sources_version=None,noise_pix = 40,hole_radius = 6.,plots=False,cache_name=None,verbose=True): """ Inpaints a map under the assumption of inhomogenous but white uncorrelated instrument noise. Pros: no products needed other than map-maker outputs of map and ivar, good inpainting despite crappy noise model. Cons: noise model has to be built for each source, so this is actually quite slow. imap -- (npol,Ny,Nx) ivar -- (Ny,Nx) fn_beam -- lambda ells: beam(ells) cache_name -- a unique string identifying the catalog+map/array/frequency/split combination to/from which the geometries are cached """ if cache_name is not None: cache_name = cache_name + "_catversion_%s" % union_sources_version try: ras,decs,gtags,pcoords,gdicts = load_cached_inpaint_geometries(cache_name) do_geoms = False if verbose: print("actsims.inpaint: loaded cached geometries for ", cache_name) except: if verbose: print("actsims.inpaint: no cached geometries found for ", cache_name, ". Generating and saving...") do_geoms = True else: do_geoms = True if do_geoms: ras,decs = sints.get_act_mr3f_union_sources(version=union_sources_version) cmb_theory_fn = lambda s,l: cosmology.default_theory().lCl(s,l) gtags = [] gdicts = {} pcoords = [] for i,(ra,dec) in enumerate(zip(ras,decs)): sel = reproject.cutout(ivar, ra=np.deg2rad(ra), dec=np.deg2rad(dec), pad=1, corner=False,npix=noise_pix,return_slice=True) if sel is None: continue civar = ivar[sel] if np.any(civar<=0): continue modrmap = civar.modrmap() modlmap = civar.modlmap() res = maps.resolution(civar.shape,civar.wcs) cimap = imap[sel] if verbose: print("actsims.inpaint: built noise model for source ",i," / ",len(ras)) scov = pixcov.scov_from_theory(modlmap,cmb_theory_fn,fn_beam,iau=False) ncov = pixcov.ncov_from_ivar(civar) pcov = scov + ncov gdicts[i] = pixcov.make_geometry(hole_radius=np.deg2rad(hole_radius/60.),n=noise_pix,deproject=True,iau=False,pcov=pcov,res=res) pcoords.append(np.array((dec,ra))) gtags.append(i) if len(gtags)>0: pcoords = np.stack(pcoords).swapaxes(0,1) if cache_name is not None: save_cached_inpaint_geometries(cache_name,ras,decs,gtags,pcoords,gdicts) if verbose: print("actsims.inpaint: cached geometries for ",cache_name) if len(gtags)>0: result = pixcov.inpaint(imap,pcoords,deproject=True,iau=False,geometry_tags=gtags,geometry_dicts=gdicts,verbose=verbose) if plots: for i,(ra,dec) in enumerate(zip(ras,decs)): sel = reproject.cutout(ivar, ra=np.deg2rad(ra), dec=np.deg2rad(dec), pad=1, corner=False,npix=noise_pix,return_slice=True) if sel is None: continue civar = ivar[sel] if np.any(civar<=0): continue modrmap = civar.modrmap() modlmap = civar.modlmap() res = maps.resolution(civar.shape,civar.wcs) cimap = imap[sel] for p in range(3): io.plot_img(cimap[p],os.environ['WORK']+"/cimap_%d_%s" % (p,str(i).zfill(2))) mimap = cimap.copy() mimap[...,modrmap<np.deg2rad(hole_radius/60.)] = np.nan for p in range(3): io.plot_img(mimap[p],os.environ['WORK']+"/masked_cimap_%d_%s" % (p,str(i).zfill(2))) cimap = result[sel] for p in range(3): io.plot_img(cimap[p],os.environ['WORK']+"/inpainted_cimap_%d_%s" % (p,str(i).zfill(2))) return result
def ilc_power(beams, noises, freqs, flux_limits_mJy, inv_noise_weighting=False, total=False, include_fg=True): from szar import foregrounds as fg beams = np.asarray(beams) noises = (np.asarray(noises) * np.pi / 180. / 60.)**2. freqs = np.asarray(freqs) flux_limits_mJy = np.asarray(flux_limits_mJy) ellmax = 25000 ells = np.arange(0, ellmax, 1) def flim(nu): return flux_limits_mJy[np.argmin(np.abs(freqs - nu))] fdict = {} fdict['tsz'] = lambda ells, nu1, nu2: fg.power_tsz( ells, nu1, nu2, fill_type="extrapolate") fdict['cibc'] = lambda ells, nu1, nu2: fg.power_cibc(ells, nu1, nu2) fdict['cibp'] = lambda ells, nu1, nu2: fg.power_cibp(ells, nu1, nu2) fdict['radps'] = lambda ells, nu1, nu2: get_radio_power( flim(nu1), nu1, flux_limit_mJy_2=flim(nu2), freq_ghz_2=nu2, flux_min_mJy=1.6e-2, num_flux=10000, prefit=True, units_Jy_sr=False) + ells * 0 fdict['ksz'] = lambda ells, nu1, nu2: fg.power_ksz_reion( ells, fill_type="extrapolate") + fg.power_ksz_late( ells, fill_type="extrapolate") kbeams = [] for beam in beams: kbeams.append(maps.gauss_beam(ells, beam)) theory = cosmology.default_theory(lpad=ellmax) cltt = theory.lCl("TT", ells) components = ['cibc', 'tsz', 'ksz', 'radps', 'cibp'] if include_fg else [] cov = np.rollaxis( maps.ilc_cov(ells, cltt, kbeams, freqs, noises, components, fdict=fdict, ellmaxes=None, data=False, fgmax=None, narray=None, noise_only=False), 2, 0) if inv_noise_weighting: ncov = np.rollaxis( maps.ilc_cov(ells, cltt, kbeams, freqs, noises, components, fdict=fdict, ellmaxes=None, data=False, fgmax=None, narray=None, noise_only=True), 2, 0) ninv = np.linalg.inv(ncov) ntot = np.sum(ninv, axis=(-2, -1)) nout = np.sum(np.einsum('lij,ljk->lik', np.einsum('lij,ljk->lik', ninv, cov), ninv), axis=(-2, -1)) / ntot**2 else: cinv = np.rollaxis(np.linalg.inv(cov), 0, 3) nout = maps.silc_noise(cinv, response=None) csub = 0 if total else cltt nell = np.nan_to_num(nout - csub) nell[ells < 2] = 0 return ells, nell