def __init__(self, bin_edges, shape, return_dl=True): self.bin_edges = bin_edges self.shape = shape self.taper, _ = omaps.get_taper(shape) loc = self.taper == 0 self.taper[loc] = np.min(self.taper[~loc]) self.return_dl = return_dl
ret = act_sim.getActpolCmbSim(None, coords, sim_idx, cmb_dir, doBeam=False, pixelFac=2) for i in range(len(ret)): ret[i] = enmap.from_flipper(ret[i]) ret[i] -= np.mean(ret[i]) return (ret[0], ret[1], ret[2]) # TQU temp_map, _, _ = get_sim(0) shape, wcs = temp_map.shape, temp_map.wcs taper, _ = maps.get_taper(shape) taper = enmap.enmap(taper, wcs=wcs) # initialize cusps overwrite = False mcm_identifier = "%lsd_le%d_nb%d_lm%d_%s_%s" % (0, lmax, nbin, lmax, coords_str, postfix) cusps_fc = cusps.power.CUSPS(mcm_identifier, taper, taper, bin_edges, lmax, None, overwrite) binner = cusps_fc.binner # bin the theory theo_bin = {} lbin_th, theo_bin['dltt'] = cusps_fc.bin_theory_scalarxscalar( l_th, theo['dltt']) lbin_th, theo_bin['dlte'] = cusps_fc.bin_theory_scalarxscalar(
mgen = maps.MapGen(shape,wcs,ps) fwhm = 5. kbeam = maps.gauss_beam(modlmap,fwhm) imap = mgen.get_map() bmap2 = maps.convolve_gaussian(imap.copy(),fwhm=fwhm,nsigma=5.0) print(bmap2.shape) bmap = maps.filter_map(imap.copy(),kbeam) taper,w2 = maps.get_taper(shape) io.plot_img(imap*taper,io.dout_dir+"bmap0.png",high_res=True) io.plot_img(bmap*taper,io.dout_dir+"bmap1.png",high_res=True) io.plot_img(bmap2*taper,io.dout_dir+"bmap2.png",high_res=True) bin_edges = np.arange(200,3000,100) binner = stats.bin2D(modlmap,bin_edges) fc = maps.FourierCalc(shape,wcs) p2d,_,_ = fc.power2d(imap*taper) cents,p1di = binner.bin(p2d/w2) p2d,_,_ = fc.power2d(bmap*taper) cents,p1db = binner.bin(p2d/w2) p2d,_,_ = fc.power2d(bmap2*taper) cents,p1db2 = binner.bin(p2d/w2)
def __init__(self, shape): self.shape = shape self.taper, _ = omaps.get_taper(shape, pad_percent=0.) loc = self.taper == 0 self.taper[loc] = np.min(self.taper[~loc])
clkk = theory.gCl('kk', ls) ellrange = np.arange(0, 6000, 1) totcls = interp1d(ls, clkk + nls, bounds_error=False, fill_value="extrapolate")(ellrange) ps = totcls.reshape((1, 1, ellrange.size)) bshape, bwcs = maps.rect_geometry(width_deg=80., px_res_arcmin=2.0, height_deg=15.) tap_per = 1. / 40. * 100. pad_per = 1. / 40. * 100. mg = maps.MapGen(bshape, bwcs, ps) fc = maps.FourierCalc(bshape, bwcs) taper, w2 = maps.get_taper(bshape, taper_percent=tap_per, pad_percent=pad_per, weight=None) bmap = mg.get_map() #io.plot_img(bmap*taper,"map.png",high_res=True) # bin_edges = np.arange(100,5000,100) # binner = stats.bin2D(enmap.modlmap(bshape,bwcs),bin_edges) # cents, bp1d = binner.bin(fc.power2d(bmap*taper)[0]/w2) # pl = io.Plotter(yscale='log') # pl.add(ellrange,totcls) # pl.add(cents,bp1d) # pl.done("cls.png")
def make_sim(self, seed): with bench.show( "Lensing operation...") if self.rank == 0 else ignore(): full, kappa = lensing.rand_map( self.fshape, self.fwcs, self.ps, lmax=self.lmax, maplmax=self.lmax, seed=seed, verbose=True if self.rank == 0 else False, dtype=self.dtype, output="lk") alms = curvedsky.map2alm(full, lmax=self.lmax) ps_data = hp.alm2cl(alms.astype(np.complex128)) del alms self.mpibox.add_to_stats("fullsky_ps", ps_data) south = full.submap(self.pos_south) equator = full.submap(self.pos_eq) ksouth = kappa.submap(self.pos_south) kequator = kappa.submap(self.pos_eq) del full del kappa if self.count == 0: self.shape['s'], self.wcs['s'] = south.shape, south.wcs self.shape['e'], self.wcs['e'] = equator.shape, equator.wcs for m in ['s', 'e']: self.taper[m], self.w2[m] = fmaps.get_taper(self.shape[m], taper_percent=18.0, pad_percent=4.0, weight=None) self.w4[m] = np.mean(self.taper[m]**4.) self.w3[m] = np.mean(self.taper[m]**3.) self.rotator = fmaps.MapRotatorEquator( self.shape['s'], self.wcs['s'], self.wdeg, self.hdeg, width_multiplier=0.6, height_multiplier=1.2, downsample=True, verbose=True if self.rank == 0 else False, pix_target_override_arcmin=self.pix_intermediate) self.taper['r'] = self.rotator.rotate(self.taper['s']) self.w2['r'] = np.mean(self.taper['r']**2.) self.w4['r'] = np.mean(self.taper['r']**4.) self.w3['r'] = np.mean(self.taper['r']**3.) self.shape['r'], self.wcs[ 'r'] = self.rotator.shape_final, self.rotator.wcs_final self.fc = {} self.binner = {} self.modlmap = {} for m in ['s', 'e', 'r']: self.fc[m] = fmaps.FourierCalc(self.shape[m], self.wcs[m]) self.modlmap[m] = enmap.modlmap(self.shape[m], self.wcs[m]) self.binner[m] = bin2D(self.modlmap[m], self.bin_edges) self.cents = self.binner['s'].centers self._init_qests() self.count += 1 south *= self.taper['s'] equator *= self.taper['e'] ksouth *= self.taper['s'] kequator *= self.taper['e'] return south, equator, ksouth, kequator
coords, r=maxr, res=px * utils.arcmin, proj="plain", oversample=2, depix=True) kstamp = kstamp[0] lstamp = lstamp[0] if i == 0: # get an edge taper map and apodize taper = maps.get_taper( l_stamp.shape, l_stamp.wcs, taper_percent=tap_per, pad_percent=pad_per, 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)
ellrange = np.arange(200, 6000, 1) cltt = theory.lCl('TT', ellrange) clee = theory.lCl('EE', ellrange) clbb = theory.lCl('BB', ellrange) pl.add(ellrange, cltt * ellrange**2., color="k") pl.add(ellrange, clee * ellrange**2., color="k") pl.add(ellrange, clbb * ellrange**2., color="k") pl.add(cents, dtt * cents**2.) pl.add(cents, dee * cents**2.) pl.add(cents, dbb * cents**2.) pl.done(out_dir + "powers_" + suffix + ".png") plot_powers(cmb, suffix="periodic", w2=1.) taper, w2 = maps.get_taper(shape, taper_percent=12.0, pad_percent=3.0, weight=None) plot_powers(cmb * taper, suffix="tapered", w2=w2) print("Pure...") #windict = pure.init_deriv_window(taper,px*np.pi/180./60.) windict = maps.init_deriv_window(taper, px * np.pi / 180. / 60.) lxMap, lyMap, modLMap, angLMap, lx, ly = maps.get_ft_attributes(shape, wcs) #cmb *= taper #fT, fE, fB = pure.iqu_to_pure_lteb(cmb[0],cmb[1],cmb[2],modlmap,angLMap,windowDict=windict,method='pure') #fT, fE, fB = maps.iqu_to_pure_lteb(cmb[0]*taper,cmb[1]*taper,cmb[2]*taper,modlmap,angLMap,windowDict=windict,method='pure') fT, fE, fB = maps.iqu_to_pure_lteb(cmb[0], cmb[1], cmb[2], modlmap, angLMap,