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