def stat_analysis(cutouts, binsize, arcmax, cents, modRMaps): profiles = [] for i in range(0, len(cutouts)): thetaRange = np.arange(0., arcmax, binsize) breali = bin2D(modRMaps[i] * 180. * 60. / np.pi, thetaRange) a = breali.bin(cutouts[i])[1] profiles.append(a) statistics = stats.getStats(profiles) mean = statistics['mean'] error = statistics['errmean'] covmat = statistics['cov'] corrcoef = stats.cov2corr(covmat) io.quickPlot2d(corrcoef, 'corrcoef.png') pl = Plotter(labelX='Distance from Center (arcminutes)', labelY='Temperature Fluctuation ($\mu K$)', ftsize=10) pl.add(cents, mean) pl.addErr(cents, mean, yerr=error) pl._ax.axhline(y=0., ls="--", alpha=0.5) pl.done(out_dir + "error.png")
def main(): arcsec = 20. px_arcsec = 0.5 a = 8. b = np.random.uniform(0., 1.) * a angle = np.random.uniform(0., 360.) * np.pi / 180. print(a, b) shape, wcs = enmap.rect_geometry(arcsec / 60., px_arcsec / 60., proj="car", pol=False) sec2rad = lambda x: x * np.pi / 180. / 3600. gell = gauss_ellipse(shape, wcs, amajor=sec2rad(a), bminor=sec2rad(b), angle=angle) io.quickPlot2d(gell, "gal.png")
def test(): arcsec = 20. px_arcsec = 0.5 shape, wcs = enmap.rect_geometry(arcsec / 60., px_arcsec / 60., proj="car", pol=False) sec2rad = lambda x: x * np.pi / 180. / 3600. N = 10000 arange = [sec2rad(3), sec2rad(9)] brange = [sec2rad(3), sec2rad(9)] angle_range = [0, 2. * np.pi] esim = EllipseSim(shape, wcs) mat = esim.get_sims(N, arange, brange, angle_range) print("Megabytes : ", mat.nbytes / 1024. / 1024.) print(mat.shape) io.quickPlot2d(mat[0, :, :], "gal0.png") io.quickPlot2d(mat[1, :, :], "gal1.png")
def stack_on_map(lite_map, width_stamp_arcminute, pix_scale, ra_range, dec_range, catalog=None, n_random_points=None): from skimage.transform import resize import orphics.tools.stats as stats width_stamp_degrees = width_stamp_arcminute / 60. Np = np.int(width_stamp_arcminute / pix_scale + 0.5) pad = np.int(Np / 2 + 0.5) print("Expected width in pixels = ", Np) lmap = lite_map stack = 0 N = 0 if catalog is not None: looprange = goodobjects print(looprange) assert n_random_points is None random = False else: assert n_random_points is not None assert len(ra_range) == 2 assert len(dec_range) == 2 looprange = range(0, n_random_points) random = True for i in looprange: if random: ra = np.random.uniform(*ra_range) dec = np.random.uniform(*dec_range) if random == False: ra = catalog[i][1] #1 for ACT catalog 2 for SDSS and redmapper dec = catalog[i][2] #2 for ACT catalog 3 for SDSS and redmapper ix, iy = lmap.skyToPix(ra, dec) if ix >= pad and ix < lmap.Nx - pad and iy >= pad and iy < lmap.Ny - pad: print(i) smap = lmap.selectSubMap(ra - width_stamp_degrees / 2., ra + width_stamp_degrees / 2., dec - width_stamp_degrees / 2., dec + width_stamp_degrees / 2.) #cutout = zoom(smap.data.copy(),zoom=(float(Np)/smap.data.shape[0],float(Np)/smap.data.shape[1])) cutout = resize(smap.data.copy(), output_shape=(Np, Np)) cutouts.append(cutout - randomstack) stack = stack + cutout xMap, yMap, modRMap, xx, yy = fmaps.getRealAttributes(smap) N = N + 1. ixs.append(ix) iys.append(iy) modRMaps.append(modRMap) else: print("skip") stack = stack / N - randomstack print(N) if catalog is not None: io.quickPlot2d(stack, out_dir + "stack.png") else: np.save('randomstamp', stack) dt = pix_scale arcmax = 20. thetaRange = np.arange(0., arcmax, dt) breal = stats.bin2D(modRMap * 180. * 60. / np.pi, thetaRange) cents, recons = breal.bin(stack) pl = Plotter(labelX='Distance from Center (arcminutes)', labelY='Temperature Fluctuation ($\mu K$)', ftsize=10) pl.add(cents, recons) pl._ax.axhline(y=0., ls="--", alpha=0.5) pl.done(out_dir + "profiles.png") return stack, cents, recons
beta = 0.01 mini_batch_size = 128 learning_rate = 0.001 num_epochs = int(1e9) pca = 500 Npix = pca if pca else ny * nx alpha_scale = 2 optimal_hidden = int(m * 1. / (alpha_scale * (num_outputs + Npix))) print("Optimal number of hidden layers : ", optimal_hidden) #training_images,Y_train, Ytrain_bayes = sim(m,ny,nx,num_outputs) training_images, Y_train, Ytrain_bayes = sim_gal(m, ny, nx, seed=100) img = training_images[:, :, 0] io.quickPlot2d(img, "img.png") my_net = FeedForward(num_features=Npix, num_outputs=num_outputs, num_nodes=num_nodes, activations=activations) X_train = prepare(training_images, pca) my_net.train(X_train, Y_train, learning_rate=learning_rate, num_epochs=num_epochs, minibatch_size=mini_batch_size, beta=beta)
theory, shape_sim, wcs_sim, lbinner=lbinner_sim, pol=True) sverif_kappa = SpectrumVerification(mpibox, theory, shape_dat, wcs_dat, lbinner=lbinner_dat, pol=False) template_dat = fmaps.simple_flipper_template_from_enmap(shape_dat, wcs_dat) nT = parray_dat.nT nP = parray_dat.nP if rank == 0: io.quickPlot2d(nT, out_dir + "nt.png") kbeam_dat = parray_dat.lbeam kbeampass = kbeam_dat if rank == 0: io.quickPlot2d(kbeampass, out_dir + "kbeam.png") fMaskCMB_T = fmaps.fourierMask(lx_dat, ly_dat, modlmap_dat, lmin=tellmin, lmax=tellmax) fMaskCMB_P = fmaps.fourierMask(lx_dat, ly_dat, modlmap_dat, lmin=pellmin, lmax=pellmax) fMask = fmaps.fourierMask(lx_dat, ly_dat,
clkk = theory.gCl("kk", fine_ells) clkk.resize((1, 1, clkk.size)) kappa_map = enmap.rand_map(shape_sim[-2:], wcs_sim, cov=clkk, scalar=True) pkk = fmaps.get_simple_power_enmap(kappa_map) debug_edges = np.arange(2, 12000, 80) dbinner = stats.bin2D(modlmap_sim, debug_edges) cents, bclkk = dbinner.bin(pkk) clkk.resize((clkk.shape[-1])) pl = io.Plotter(scaleY='log', scaleX='log') pl.add(fine_ells, clkk) pl.add(cents, bclkk) pl.done(out_dir + "clkk.png") phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True) io.quickPlot2d(kappa_map, out_dir + "kappa_map.png") io.quickPlot2d(phi, out_dir + "phi.png") alpha_pix = enmap.grad_pixf(fphi) # === SIM AND RECON LOOP === kappa_stack = {} if cluster: profiles = {} else: apowers = {} cpowers = {} for polcomb in pol_list: kappa_stack[polcomb] = 0. if cluster: profiles[polcomb] = []
print((ix, iy)) c += 1 ixs.append(ix) iys.append(iy) print(c) #sys.exit() holeArc = 10. holeFrac = 1. ra_range = [lmap.x1 - 360., lmap.x0] dec_range = [lmap.y0, lmap.y1] stack, cents, recons = fmaps.stack_on_map(lmap, 60., 0.5, ra_range, dec_range, ras, decs) io.quickPlot2d(stack, out_dir + "stack.png") pl = io.Plotter(labelX='Distance from Center (arcminutes)', labelY='Temperature Fluctuation ($\mu K$)', ftsize=10) pl.add(cents, recons) pl._ax.axhline(y=0., ls="--", alpha=0.5) pl.done(out_dir + "profiles.png") mask = inp.maskLiteMap(lmap, iys, ixs, holeArc, holeFrac) io.highResPlot2d(mask.data, out_dir + "mask.png")
def stack_on_map(lite_map, width_stamp_arcminute, pix_scale, ra_range, dec_range, catalog=None, n_random_points=None): width_stamp_degrees = width_stamp_arcminute / 60. Np = np.int(width_stamp_arcminute / pix_scale + 0.5) pad = np.int(Np / 2 + 0.5) print("Expected width in pixels = ", Np) lmap = lite_map stack = 0 N = 0 if catalog is not None: looprange = range(0, len(catalog)) assert n_random_points is None random = False else: assert n_random_points is not None assert len(ra_range) == 2 assert len(dec_range) == 2 looprange = range(0, n_random_points) random = True print(looprange) for i in looprange: banana = True mass = catalog[i][10] if random: ra = np.random.uniform(*ra_range) dec = np.random.uniform(*dec_range) if random == False: ra = catalog[i][1] #1 for ACT catalog 2 for SDSS dec = catalog[i][2] #2 for ACT catalog 3 for SDSS for j in range(0, 2130): distance = np.sqrt((ra - RAps[j])**2 + (dec - DECps[j])**2) crit = 0.25 if distance < crit: banana = False print('too close') ix, iy = lmap.skyToPix(ra, dec) if ix >= pad and ix < lmap.Nx - pad and iy >= pad and iy < lmap.Ny - pad and banana == True and mass > 8: print(i) #print(ra,dec) smap = lmap.selectSubMap(ra - width_stamp_degrees / 2., ra + width_stamp_degrees / 2., dec - width_stamp_degrees / 2., dec + width_stamp_degrees / 2.) #print (smap.data.shape) #cutout = zoom(smap.data.copy(),zoom=(float(Np)/smap.data.shape[0],float(Np)/smap.data.shape[1]) cutout = resize(smap.data.copy(), output_shape=(Np, Np)) - randomstack xMap, yMap, modRMap, xx, yy = fmaps.getRealAttributes(smap) dt = pix_scale arcmax = 20. thetaRange = np.arange(0., arcmax, dt) breali = bin2D(modRMap * 180. * 60. / np.pi, thetaRange) a = breali.bin(cutout)[1] profiles.append(a) io.quickPlot2d(cutout, str(i) + "cutout.png") #print (cutout.shape) stack = stack + cutout N = N + 1 else: print("skip") stack = stack / N #-randomstack #print(stack.shape()) #print(smap.data.shape) # print(stack) print(N) statistics = stats.getStats(profiles) mean = statistics['mean'] error = statistics['errmean'] corrcoef = statistics['corr'] covmat = statistics['covmat'] print(mean / error) np.save('statistics', statistics) #np.save('newrandomstamp',stack) # io.quickPlot2d(stack,out_dir+"newACTstack.png") dt = pix_scale arcmax = 20. thetaRange = np.arange(0., arcmax, dt) breal = bin2D(modRMap * 180. * 60. / np.pi, thetaRange) cents, recons = breal.bin(stack) pl = Plotter(labelX='Distance from Center (arcminutes)', labelY='Temperature Fluctuation ($\mu K$)', ftsize=10) pl.add(cents, mean) pl.addErr(cents, mean, yerr=error) pl._ax.axhline(y=0., ls="--", alpha=0.5) pl.done(out_dir + "error.png") print(covmat) io.quickPlot2d(covmat, 'covmat.png') return (stack, cents, recons)
parray_dat.add_theory(cc, theory, lmax) taper_percent = 14.0 pad_percent = 2.0 Ny, Nx = shape_dat taper = fmaps.cosineWindow(Ny, Nx, lenApodY=int(taper_percent * min(Ny, Nx) / 100.), lenApodX=int(taper_percent * min(Ny, Nx) / 100.), padY=int(pad_percent * min(Ny, Nx) / 100.), padX=int(pad_percent * min(Ny, Nx) / 100.)) w2 = np.mean(taper**2.) w3 = np.mean(taper**3.) w4 = np.mean(taper**4.) if rank == 0: io.quickPlot2d(taper, out_dir + "taper.png") print(("w2 : ", w2)) px_dat = analysis_resolution Nsims = 10 avg = 0. for i in range(Nsims): print(i) cmb = parray_dat.get_unlensed_cmb(seed=i) ltt2d = fmaps.get_simple_power_enmap(cmb * taper) ccents, ltt = lbinner_dat.bin(ltt2d) / w2 avg += ltt ltt = avg / Nsims iltt2d = theory.uCl("TT", parray_dat.modlmap)
ks,zs,Pkz = getPkz(pkzfile) from scipy.interpolate import RectBivariateSpline pkint = RectBivariateSpline(ks,zs,Pkz,kx=3,ky=3) ks2,zs2,Pkz2 = getPkz(pkzfile2) kseval = ks zseval = zs io.quickPlot2d(Pkz,"pkz.png") io.quickPlot2d(pkint(kseval,zseval),"pkzint.png") lc = LimberCosmology(lmax=8000,pickling=True,kmax=400.,pkgrid_override=pkint) from alhazen.shear import dndz step = 0.01 zedges = np.arange(0.,3.0+step,step) zcents = (zedges[1:]+zedges[:-1])/2. dndzs = dndz(zcents) pkz_camb = lc.PK.P(zseval, kseval, grid=True).T io.quickPlot2d(pkz_camb,"pkz_camb.png")
maps, z, kappa, szMapuK, projectedM500, trueM500, trueR500, pixScaleX, pixScaleY = sim.getMaps( snap, massIndex, freqGHz=150., sourceZ=1100.) print((z, projectedM500, trueM500, trueR500, pixScaleX, pixScaleY)) kappaMap, szMap, projectedM500, z = sim.getKappaSZ(snap, massIndex, shape, wcs, apodWidth=500) print((projectedM500, z)) print("done") out_dir = os.environ['WWW'] io.quickPlot2d(kappaMap, out_dir + "kappa.png") #,crange=[-0.1,0.1]) io.highResPlot2d(szMap, out_dir + "sz.png", crange=[-50, 0]) B = fft_gen(kappaMap, axes=[-2, -1], flags=['FFTW_MEASURE']) modlmap = get_modlmap(kappaMap) io.quickPlot2d(modlmap, out_dir + "modlmap.png") #,crange=[-0.1,0.1]) phi, fphi = kappa_to_phi(kappaMap, modlmap, return_fphi=True) io.quickPlot2d(phi, out_dir + "phi.png") alpha_pix = enmap.grad_pixf(fphi) # alpha_pix2 = enmap.grad_pix(phi) print((alpha_pix.shape)) # print alpha_pix2.shape
decs = np.random.uniform(bbox[0, 0], bbox[1, 0], size=N) ras = np.random.uniform(bbox[0, 1], bbox[1, 1], size=N) print((ras.min() * 180. / np.pi, ras.max() * 180. / np.pi)) print((decs.min() * 180. / np.pi, decs.max() * 180. / np.pi)) # coords = np.vstack((decs,ras)) # print "getting pixels..." # pixs = gal_map.sky2pix(coords) # print "binning..." # dat,xedges,yedges = np.histogram2d(pixs[1,:],pixs[0,:],bins=shape) mapper = CatMapper(shape, wcs, ras * 180. / np.pi, decs * 180. / np.pi) gal_map = mapper.get_map() print((gal_map.sum())) print((gal_map.sum() - N)) gal_map = enmap.smooth_gauss(gal_map, 2.0 * np.pi / 180. / 60.) #gal_map = enmap.smooth_gauss(enmap.ndmap(dat.astype(np.float32),wcs),2.0*np.pi/180./60.) print("plotting...") io.highResPlot2d(gal_map, out_dir + "galmap.png") fc = enmap.FourierCalc(shape, wcs) p2d, d, d = fc.power2d(gal_map) io.quickPlot2d(np.fft.fftshift(np.log10(p2d)), out_dir + "logp2d.png") io.quickPlot2d(np.fft.fftshift((p2d)), out_dir + "p2d.png")
else: pol_list = ['TT'] debug = False out_dir = os.environ['WWW'] + "plots/halotest/smallpatch_" # === COSMOLOGY === cc = ClusterCosmology(lmax=lmax, pickling=True) parray_sim.add_cosmology(cc) parray_dat.add_cosmology(cc) theory = cc.theory kappa_map = parray_sim.get_kappa(ktype="grf", vary=False) phi, fphi = lt.kappa_to_phi(kappa_map, parray_sim.modlmap, return_fphi=True) io.quickPlot2d(kappa_map, out_dir + "kappa_map.png") io.quickPlot2d(phi, out_dir + "phi.png") alpha_pix = enmap.grad_pixf(fphi) # === EXPERIMENT === fine_ells = parray_dat.fine_ells kbeam_sim = parray_sim.lbeam # === SIM AND RECON LOOP === kappa_stack = {} apowers = {} cpowers = {}
lensed = lensing.lens_map(unlensed.copy(), grad_phi, order=lens_order) lensed += parray_dat.get_noise_sim(seed=index + 100000) llteb, dummy = sverif_cmb.add_power("lensed", lensed) qest.updateTEB_X(llteb, alreadyFTed=True) qest.updateTEB_Y(alreadyFTed=True) with io.nostdout(): rawkappa = qest.getKappa("TT").real kappa_recon = enmap.ndmap(rawkappa, wcs_dat) rcents, recon1d = binner_dat.bin(kappa_recon) mpibox.add_to_stats("kapparecon1d", recon1d) mpibox.add_to_stack("kapparecon", kappa_recon) if rank == 0 and k == 0: io.quickPlot2d(kappa, out_dir + "kappa.png") io.quickPlot2d(kappa_model, out_dir + "kappamodel.png") io.quickPlot2d(unlensed, out_dir + "unlensed.png") io.quickPlot2d(lensed - unlensed, out_dir + "difflensed.png") # io.quickPlot2d(pdelensed-unlensed,out_dir+"diffpdelensed.png") io.quickPlot2d(kappa_recon, out_dir + "rtt.png") lrtt, likk = sverif_kappa.add_power("rttXikk", kappa_recon, imap2=kappa) # BEGIN ITERATIVE DELENSING kappa_iter_recon = kappa_model.copy() niter = 10 # if rank==0 and k==0: # pl = io.Plotter(scaleY='log')
shape,wcs = enmap.rect_geometry(deg*60.,px,proj="car",pol=False) modlmap = enmap.modlmap(shape,wcs) lxmap,lymap,modlmap,angmap,lx,ly = fmaps.get_ft_attributes_enmap(shape,wcs) amajor = 3000 bminor = 100 angle = np.pi/4. r_square = ((lxmap)*np.cos(angle)+(lymap)*np.sin(angle))**2./amajor**2.+((lxmap)*np.sin(angle)-(lymap)*np.cos(angle))**2./bminor**2. elfact = (1.+1.e3*np.exp(-r_square)) #elfact = 1. p2d = elfact * cmb.white_noise_with_atm_func(modlmap,uk_arcmin=10.0,lknee=4000,alpha=-4.5,dimensionless=False,TCMB=2.7255e6) p2d[modlmap<90]=0. p2d[modlmap>4000]=0. io.quickPlot2d(np.fft.fftshift(np.log10(p2d)),io.dout_dir+"p2d.png") mg = enmap.MapGen(shape,wcs,p2d.reshape(1,1,modlmap.shape[0],modlmap.shape[1])) imap = mg.get_map() io.quickPlot2d(imap,io.dout_dir+"cmb.png") # imap2 = mg.get_map() # io.quickPlot2d(imap2,io.dout_dir+"cmb2.png") dtype = np.complex128 rtype = np.zeros([0],dtype=dtype).real.dtype print("alms...") alm = curvedsky.map2alm(imap,lmax=4000) powfac = 0.5 ps_data = enmap.multi_pow(alm*alm.conj()[None,None],powfac).astype(rtype) print(alm) print((alm.shape))
for k, i in enumerate(my_tasks): with io.nostdout(): hpmap, alm = hp.synfast(cls, nside, alm=True, pol=False) lmap.loadDataFromHealpixMap(hpmap, interpolate=False, hpCoords="J2000") del hpmap if k == 0: taper, w2 = fmaps.get_taper(lmap.data.shape, taper_percent=12.0, pad_percent=3.0, weight=None) lmap.data *= taper if rank == 0 and k == 0: io.quickPlot2d(lmap.data, io.dout_dir + "flipper_map.png") p = ft.powerFromLiteMap(lmap) if k == 0: binner = stats.bin2D(p.modLMap, bin_edges) #pwin = hp.pixwin(nside) #pells = np.arange(0,pwin.size) #from scipy.interpolate import interp1d pwin2d = 1. #interp1d(pells,pwin,bounds_error=False,fill_value=0.)(p.modLMap) p2d = np.nan_to_num(p.powerMap / w2 / pwin2d**2.) cents, p1d = binner.bin(p2d) cls = hp.alm2cl(alm) mpibox.add_to_stack("full", cls)
cov = ps width_deg = 20. pix = 2.0 shape, wcs = enmap.get_enmap_patch(width_deg * 60., pix, proj="CAR", pol=True) m1 = enmap.rand_map(shape, wcs, cov, scalar=True, seed=None, power2d=False, pixel_units=False) modlmap = m1.modlmap() io.quickPlot2d(m1[0], out_dir + "m1.png") cltt = ps[0, 0] ells = np.arange(0, cltt.size) pl = io.Plotter(scaleY='log') pl.add(ells, cltt * ells**2.) debug_edges = np.arange(200, 2000, 80) dbinner = stats.bin2D(modlmap, debug_edges) powermap = fmaps.get_simple_power_enmap(m1[0]) cents, dcltt = dbinner.bin(powermap) pl.add(cents, dcltt * cents**2., label="power of map") pa = fmaps.PatchArray(shape, wcs, skip_real=True) pa.add_noise_2d(powermap) nT = pa.nT
padY=0, padX=0) w2 = np.mean(taper**2.) w4 = np.mean(taper**4.) modlmap = imap.modlmap() ellmax = 6000 ellmin = 200 ellwidth = 40 bin_edges = np.arange(ellmin, ellmax, ellwidth) binner = stats.bin2D(modlmap, bin_edges) imap = imap * taper phi = phi * taper if i == 0: io.quickPlot2d(phi, os.environ['WORK'] + "/web/plots/phimap.png") print("IQU to TEB...") teb = enmap.ifft(enmap.map2harm(imap)).real print("Powers...") t = teb[0, :, :] e = teb[1, :, :] b = teb[2, :, :] spec2d = {} spec2d['tt'] = np.nan_to_num(fmaps.get_simple_power_enmap(t)) / w2 spec2d['ee'] = np.nan_to_num(fmaps.get_simple_power_enmap(e)) / w2 spec2d['bb'] = np.nan_to_num(fmaps.get_simple_power_enmap(b)) / w2 spec2d['te'] = np.nan_to_num(fmaps.get_simple_power_enmap(t, enmap2=e)) / w2
p2d, _, _ = fc.power2d(nmap * taper) / w2 cents, p1d3 = binner.bin(p2d) nmap = mg.get_map().submap(enmap.box(shape, wcs)) fc4 = enmap.FourierCalc(nmap.shape, nmap.wcs) taper4, w24 = fmaps.get_taper(nmap.shape, taper_percent=12.0, pad_percent=3.0, weight=None) binner4 = stats.bin2D(nmap.modlmap(), bin_edges) p2d, _, _ = fc4.power2d(nmap * taper4) / w24 shape4 = nmap.shape wcs4 = nmap.wcs cents, p1d4 = binner4.bin(p2d) if rank == 0 and k == 0: io.quickPlot2d(nmap * taper4, io.dout_dir + "nptapered.png") nmap = mgP.get_map() p2d, _, _ = fc.power2d(nmap * taper) / w2 cents, p1d5 = binner.bin(p2d) alm = curvedsky.map2alm(imap.astype(np.float64), lmax=4000) del imap cls = hp.alm2cl(alm) mpibox.add_to_stack("full", cls) mpibox.add_to_stack("cut", p1d) mpibox.add_to_stack("cut2", p1d2) mpibox.add_to_stack("cut3", p1d3) mpibox.add_to_stack("cut4", p1d4) mpibox.add_to_stack("cut5", p1d5)
else: clkk = theory.gCl("kk", fine_ells) clkk.resize((1, 1, clkk.size)) kappa_map = enmap.rand_map(shape_sim[-2:], wcs_sim, cov=clkk, scalar=True) if debug: pkk = fmaps.get_simple_power_enmap(kappa_map) debug_edges = np.arange(kellmin, 8000, 80) dbinner = stats.bin2D(modlmap_sim, debug_edges) cents, bclkk = dbinner.bin(pkk) clkk.resize((clkk.shape[-1])) pl = io.Plotter(scaleY='log', scaleX='log') pl.add(fine_ells, clkk) pl.add(cents, bclkk) pl.done(out_dir + "clkk.png") phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True) io.quickPlot2d(kappa_map, out_dir + "kappa_map.png") io.quickPlot2d(phi, out_dir + "phi.png") alpha_pix = enmap.grad_pixf(fphi) # === EXPERIMENT === if deconvolve_beam: ntfunc = cmb.get_noise_func(beam_arcmin, noise_T_uK_arcmin, ellmin=tellmin, ellmax=tellmax, TCMB=TCMB) npfunc = cmb.get_noise_func(beam_arcmin, noise_P_uK_arcmin, ellmin=pellmin, ellmax=pellmax,
alpha=alpha, color="C" + str(i + 2)) pl.legendOn(labsize=10) pl.done(out_dir + "iter_profs.png") lens_order = 5 nstep = 9 iters = 2 unlensed = unlensed * TCMB lensed = lensing.lens_map_flat_pix(unlensed, alpha_pix, order=lens_order) iter_delensed = lensed phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True) grad_phi = enmap.grad(phi) / (iters) for i in range(1, iters + 1): print(i) iter_delensed = lensing.delens_map(iter_delensed, grad_phi, nstep=nstep, order=lens_order, mode="spline", border="cyclic") iter_residual = iter_delensed - unlensed lens_residual = lensed - unlensed io.quickPlot2d(lens_residual, out_dir + "lensres.png") io.quickPlot2d(iter_residual, out_dir + "iterres.png")
if rank == 0: print("Binners...") lbin_edges = np.arange(kellmin, kellmax, 200) lbinner_dat = stats.bin2D(modlmap_dat, lbin_edges) if rank == 0: print("Cosmology...") # === COSMOLOGY === theory, cc, lmax = aio.theory_from_config(Config, cosmology_section, dimensionless=False) parray_dat.add_theory(cc, theory, lmax, orphics_is_dimensionless=False) template_dat = fmaps.simple_flipper_template_from_enmap(shape_dat, wcs_dat) nT = parray_dat.nT nP = parray_dat.nP if rank == 0: io.quickPlot2d(nT, out_dir + "nt.png") kbeam_dat = parray_dat.lbeam kbeampass = kbeam_dat if rank == 0: io.quickPlot2d(kbeampass, out_dir + "kbeam.png") fMaskCMB_T = fmaps.fourierMask(lx_dat, ly_dat, modlmap_dat, lmin=tellmin, lmax=tellmax) fMaskCMB_P = fmaps.fourierMask(lx_dat, ly_dat, modlmap_dat, lmin=pellmin, lmax=pellmax) fMask = fmaps.fourierMask(lx_dat, ly_dat,
cosmology_section, dimensionless=False) parray_dat.add_theory(cc, theory, lmax, orphics_is_dimensionless=False) taper_percent = 14.0 pad_percent = 6.0 Ny, Nx = shape_dat[-2:] taper = fmaps.cosineWindow(Ny, Nx, lenApodY=int(taper_percent * min(Ny, Nx) / 100.), lenApodX=int(taper_percent * min(Ny, Nx) / 100.), padY=int(pad_percent * min(Ny, Nx) / 100.), padX=int(pad_percent * min(Ny, Nx) / 100.)) w2 = np.mean(taper**2.) if rank == 0: io.quickPlot2d(taper, pout_dir + "taper.png") print(("w2 : ", w2)) px_dat = analysis_resolution sverif_cmb = SpectrumVerification(mpibox, theory, shape_dat, wcs_dat, lbinner=lbinner_dat, pol=pol, iau_convention=iau_convention) k = -1 for index in my_tasks:
def debug(): teb = enmap.ifft(enmap.map2harm(unlensed)).real lteb = enmap.ifft(klteb).real if pol: io.quickPlot2d(unlensed[0], out_dir + "tmap.png") io.quickPlot2d(unlensed[1], out_dir + "qmap.png") io.quickPlot2d(unlensed[2], out_dir + "umap.png") io.quickPlot2d(teb[1], out_dir + "emap.png") io.quickPlot2d(teb[2], out_dir + "bmap.png") io.quickPlot2d(lensed[0], out_dir + "ltmap.png") io.quickPlot2d(lensed[1], out_dir + "lqmap.png") io.quickPlot2d(lensed[2], out_dir + "lumap.png") io.quickPlot2d(lteb[1], out_dir + "lemap.png") io.quickPlot2d(lteb[2], out_dir + "lbmap.png") else: io.quickPlot2d(unlensed, out_dir + "tmap.png") io.quickPlot2d(lensed, out_dir + "ltmap.png") t = teb[0, :, :] e = teb[1, :, :] b = teb[2, :, :] nt = noise[0, :, :] ne = noise[1, :, :] nb = noise[2, :, :] ntt2d = np.nan_to_num(fmaps.get_simple_power_enmap(nt) / kbeam_sim**2.) nee2d = np.nan_to_num(fmaps.get_simple_power_enmap(ne) / kbeam_sim**2.) nbb2d = np.nan_to_num(fmaps.get_simple_power_enmap(nb) / kbeam_sim**2.) utt2d = fmaps.get_simple_power_enmap(t) uee2d = fmaps.get_simple_power_enmap(e) ute2d = fmaps.get_simple_power_enmap(enmap1=t, enmap2=e) ubb2d = fmaps.get_simple_power_enmap(b) debug_edges = np.arange(2, 12000, 80) dbinner = stats.bin2D(modlmap_sim, debug_edges) cents, utt = dbinner.bin(utt2d) cents, uee = dbinner.bin(uee2d) cents, ute = dbinner.bin(ute2d) cents, ntt = dbinner.bin(ntt2d) cents, nee = dbinner.bin(nee2d) cents, nbb = dbinner.bin(nbb2d) #cents, ubb = dbinner.bin(ubb2d) tl = lteb[0, :, :] el = lteb[1, :, :] bl = lteb[2, :, :] ltt2d = fmaps.get_simple_power_enmap(tl) lee2d = fmaps.get_simple_power_enmap(el) lte2d = fmaps.get_simple_power_enmap(enmap1=tl, enmap2=el) lbb2d = fmaps.get_simple_power_enmap(bl) cents, ltt = dbinner.bin(ltt2d) cents, lee = dbinner.bin(lee2d) cents, lte = dbinner.bin(lte2d) cents, lbb = dbinner.bin(lbb2d) lcltt, lclee, lclte, lclbb = ( x for x in cmb.unpack_cmb_theory(theory, fine_ells, lensed=True)) cltt, clee, clte, clbb = ( x for x in cmb.unpack_cmb_theory(theory, fine_ells, lensed=False)) pl = io.Plotter(scaleY='log', scaleX='log') pl.add(cents, utt * cents**2., color="C0", marker="o", ls="none") pl.add(cents, uee * cents**2., color="C1", marker="o", ls="none") #pl.add(cents,ubb*cents**2.,color="C2",ls="-") pl.add(fine_ells, cltt * fine_ells**2., color="C0", ls="--") pl.add(fine_ells, clee * fine_ells**2., color="C1", ls="--") #pl.add(fine_ells,clbb*fine_ells**2.,color="C2",ls="--") pl.done(out_dir + "ccomp.png") pl = io.Plotter(scaleX='log') pl.add(cents, ute * cents**2., color="C0", marker="o", ls="none") pl.add(fine_ells, clte * fine_ells**2., color="C0", ls="--") pl.done(out_dir + "ccompte.png") # sells,stt,see,sbb,ste = np.loadtxt("data/cl_lensed.dat",unpack=True) # stt *= 2.*np.pi/TCMB**2./sells/(sells+1.) # see *= 2.*np.pi/TCMB**2./sells/(sells+1.) # sbb *= 2.*np.pi/TCMB**2./sells/(sells+1.) pl = io.Plotter(scaleY='log') #,scaleX='log') # pl.add(sells,stt*sells**2.,color="C0",ls="-") # pl.add(sells,see*sells**2.,color="C1",ls="-") # pl.add(sells,sbb*sells**2.,color="C2",ls="-") pl.add(cents, ltt * cents**2., color="C0", marker="o", ls="none") pl.add(cents, lee * cents**2., color="C1", marker="o", ls="none") pl.add(cents, lbb * cents**2., color="C2", marker="o", ls="none") pl.add(cents, ntt * cents**2., color="C0", ls="-.", alpha=0.4) pl.add(cents, nee * cents**2., color="C1", ls="-.", alpha=0.4) pl.add(cents, nbb * cents**2., color="C2", ls="-.", alpha=0.4) pl.add(fine_ells, lcltt * fine_ells**2., color="C0", ls="--") pl.add(fine_ells, lclee * fine_ells**2., color="C1", ls="--") pl.add(fine_ells, lclbb * fine_ells**2., color="C2", ls="--") pl.done(out_dir + "lccomp.png") pl = io.Plotter(scaleX='log') pl.add(cents, lte * cents**2., color="C0", ls="-") pl.add(fine_ells, lclte * fine_ells**2., color="C0", ls="--") pl.done(out_dir + "lccompte.png")
unlensed = enmap.rand_map(shape_sim, wcs_sim, ps) lensed = lensing.lens_map_flat_pix(unlensed, alpha_pix, order=lens_order) if noiseless_cmb: measured = lensed else: klteb = enmap.map2harm(lensed) klteb_beam = klteb * kbeam_sim lteb_beam = enmap.ifft(klteb_beam).real noise = enmap.rand_map(shape_sim, wcs_sim, ps_noise, scalar=True) observed = lteb_beam + noise fkmaps = fftfast.fft(observed, axes=[-2, -1]) fkmaps = np.nan_to_num(fkmaps / kbeam_sim) * fMaskCMB_T measured = enmap.samewcs( fftfast.ifft(fkmaps, axes=[-2, -1], normalize=True).real, observed) if i == 0: io.quickPlot2d((measured - lensed), out_dir + "test2.png") grad_phi = grad_phi_true delensed = lensing.delens_map(measured.copy(), grad_phi, nstep=nstep, order=lens_order, mode="spline", border="cyclic") residual = delensed - unlensed res_stack += residual res_stack /= Nstack p = res_stack * 100. / unlensed p[np.abs(p) > 100] = np.nan
def stack_on_map(lite_map, width_stamp_arcminute, pix_scale, ra_range, dec_range, catalog=None, n_random_points=None): width_stamp_degrees = width_stamp_arcminute / 60. Np = np.int(width_stamp_arcminute / pix_scale + 0.5) pad = np.int(Np / 2 + 0.5) print("Expected width in pixels = ", Np) lmap = lite_map stack = 0 N = 0 if catalog is not None: looprange = range(0, len(catalog)) assert n_random_points is None random = False else: assert n_random_points is not None assert len(ra_range) == 2 assert len(dec_range) == 2 looprange = range(0, n_random_points) random = True for i in looprange: if random: ra = np.random.uniform(*ra_range) dec = np.random.uniform(*dec_range) else: ra = catalog[i][1] dec = catalog[i][2] ix, iy = lmap.skyToPix(ra, dec) if ix >= pad and ix < lmap.Nx - pad and iy >= pad and iy < lmap.Ny - pad: print(i) #print(ra,dec) smap = lmap.selectSubMap(ra - width_stamp_degrees / 2., ra + width_stamp_degrees / 2., dec - width_stamp_degrees / 2., dec + width_stamp_degrees / 2.) #print (smap.data.shape) #cutout = zoom(smap.data.copy(),zoom=(float(Np)/smap.data.shape[0],float(Np)/smap.data.shape[1])) cutout = resize(smap.data.copy(), output_shape=(Np, Np)) #print (cutout.shape) stack = stack + cutout xMap, yMap, modRMap, xx, yy = fmaps.getRealAttributes(smap) N = N + 1. else: print("skip") stack = stack / N #print(stack.shape()) #print(smap.data.shape) print(stack) print(N) io.quickPlot2d(stack, out_dir + "stackrandom.png") dt = pix_scale arcmax = 20. thetaRange = np.arange(0., arcmax, dt) breal = bin2D(modRMap * 180. * 60. / np.pi, thetaRange) cents, recons = breal.bin(stack) pl = Plotter(labelX='Distance from Center (arcminutes)', labelY='Temperature Fluctuation ($\mu K$)', ftsize=10) pl.add(cents, recons) pl._ax.axhline(y=0., ls="--", alpha=0.5) pl.done(out_dir + "randomprofiles.png") return stack, cents, recons
shape, wcs = enmap.geometry(pos=[[-hwidth * arcmin, -hwidth * arcmin], [hwidth * arcmin, hwidth * arcmin]], res=px * arcmin, proj="car") shape = (3, ) + shape np.random.seed(100) ps2d = enmap.spec2flat(shape, wcs, ps) ps2dtest = ps2d[0, 0] psfunc = interp1d(ells, cctt, fill_value=0., bounds_error=False) modlmap = enmap.modlmap(shape, wcs) ps2dalt = psfunc(modlmap) io.quickPlot2d(np.log(ps2dtest), out_dir + "ps1.png") io.quickPlot2d(np.log(ps2dalt), out_dir + "ps2.png") #io.quickPlot2d(np.nan_to_num(ps2dtest/ps2dalt),out_dir+"psrat.png") ellbin_edges = np.arange(2, 3000, 60) binner = stats.bin2D(modlmap, ellbin_edges) cents, ps1dtest = binner.bin(ps2dtest) cents, ps1dalt = binner.bin(ps2dalt) pl = io.Plotter(scaleY='log', scaleX='log') pl.add(ells, cctt * ells**2., color="C1", ls="-") pl.add(cents, ps1dtest * cents**2., color="C0", ls="-") pl.add(cents, ps1dalt * cents**2., color="C0", ls="--") pl.done(out_dir + "ccomp1d.png")
out_dir = os.environ['WWW']+"plots/cgauss_" # Efficiently distribute sims over MPI cores num_each,each_tasks = mpi_distribute(Nsims,numcores) # Initialize a container for stats and stacks mpibox = MPIStats(comm,num_each,tag_start=333) if rank==0: print(("At most ", max(num_each) , " tasks...")) # What am I doing? my_tasks = each_tasks[rank] for k,index in enumerate(my_tasks): noise = ngen.get_map() mkappa = true2d+noise if k==0 and rank==0: io.quickPlot2d(noise,out_dir+"nstamp.png") print(k) cents, prof = rbinner.bin(mkappa) mpibox.add_to_stats('prof',prof) mpibox.add_to_stack('mkappa',mkappa) mpibox.get_stacks() mpibox.get_stats() if rank==0: io.quickPlot2d(mpibox.stacks['mkappa'],out_dir+"stack.png") mean = mpibox.stats['prof']['mean'] cov = mpibox.stats['prof']['covmean'] siginv = np.linalg.inv(cov)
rxr = mpibox.stats['rxr'] sdn0 = mpibox.stats['superdumbs'] area = S0.area()*(180./np.pi)**2. print(("area: ", area, " sq.deg.")) fsky = area/41250. print(("fsky: ",fsky)) diagraw = np.sqrt(np.diagonal(rxr_raw['cov'])*cents*np.diff(lbin_edges)*fsky) diagn0sub = np.sqrt(np.diagonal(rxr['cov'])*cents*np.diff(lbin_edges)*fsky) idiag = np.sqrt(np.diagonal(ixr['cov'])*cents*np.diff(lbin_edges)*fsky) cents,clkk1d = lbinner.bin(clkk2d) idiag_est = clkk1d+(3.*(idiag**2.-clkk1d**2.)/clkk1d) io.quickPlot2d(stats.cov2corr(rxr['covmean']),pout_dir+"rcorr.png") io.quickPlot2d(stats.cov2corr(rxr_raw['covmean']),pout_dir+"corr.png") # if paper and not(unlensed): # np.save(pout_dir+"covmat_"+str(area)+"sqdeg.npy",rxr['cov']) # np.save(pout_dir+"lbin_edges_"+str(area)+"sqdeg.npy",lbin_edges) # import cPickle as pickle # pickle.dump((cents,mpibox.stats['noisett']['mean']),open(pout_dir+"noise.pkl",'wb')) ellrange = np.arange(2,kellmax,1) clkk = theory.gCl('kk',ellrange) pl = io.Plotter(scaleY='log',labelX="$L$",labelY="$C^{\\kappa\\kappa}_L$")#,scaleX='log') pl.add(ellrange,clkk,color="k",lw=3) io.save_cols(pout_dir+"_plot_clkk_theory.txt",(ellrange,clkk)) pl.addErr(cents-140,ixr['mean'],yerr=ixr['errmean'],ls="none",marker="o",label='Input x Reconstruction') io.save_cols(pout_dir+"_plot_inputXrecon.txt",(cents,ixr['mean'],ixr['errmean']))