bin_edges = np.arange(kellmin, kellmax, 80) whiteNoiseT = (np.pi / (180. * 60))**2. * noiseT**2. #/ TCMB**2. whiteNoiseP = (np.pi / (180. * 60))**2. * noiseP**2. #/ TCMB**2. for k, i in enumerate(myIs): print i lensedTLm = lm.liteMapFromFits(lensedTPath(i)) lensedQLm = lm.liteMapFromFits(lensedQPath(i)) lensedULm = lm.liteMapFromFits(lensedUPath(i)) kappaLm = lm.liteMapFromFits(kappaPath(i)) if k == 0: lxMap, lyMap, modLMap, thetaMap, lx, ly = fmaps.getFTAttributesFromLiteMap( lensedTLm) beamTemplate = fmaps.makeTemplate(l, beamells, modLMap) fMaskCMB = fmaps.fourierMask(lx, ly, modLMap, lmin=cmbellmin, lmax=cmbellmax) fMask = fmaps.fourierMask(lx, ly, modLMap, lmin=kellmin, lmax=kellmax) ellNoise = np.arange(0, modLMap.max()) Ntt = ellNoise * 0. + whiteNoiseT Npp = ellNoise * 0. + whiteNoiseP Ntt[0] = 0. Npp[0] = 0. gGenT = fmaps.GRFGen(lensedTLm.copy(), ellNoise, Ntt, bufferFactor=1) gGenP1 = fmaps.GRFGen(lensedTLm.copy(), ellNoise, Npp, bufferFactor=1)
print "Interpolating Cls..." #from orphics.tools.cmb import loadTheorySpectraFromCAMB #theory = loadTheorySpectraFromCAMB(cambRoot,unlensedEqualsLensed=False,useTotal=False,TCMB = TCMB,lpad=9000) from orphics.theory.cosmology import Cosmology cc = Cosmology(lmax=8000,pickling=True) theory = cc.theory ellkk = np.arange(2,9000,1) Clkk = theory.gCl("kk",ellkk) lxMap,lyMap,modLMap,thetaMap,lx,ly = fmaps.getFTAttributesFromLiteMap(templateMap) print "Making white noise..." nT,nP = fmaps.whiteNoise2D([noiseT,noiseP],beamArcmin,modLMap,TCMB=TCMB) fMask = fmaps.fourierMask(lx,ly,modLMap,lmin=cmbellmin,lmax=cmbellmax) fMaskK = fmaps.fourierMask(lx,ly,modLMap,lmin=kellmin,lmax=kellmax) qest = Estimator(templateMap, theory, theorySpectraForNorm=None, noiseX2dTEB=[nT,nP,nP], noiseY2dTEB=[nT,nP,nP], fmaskX2dTEB=[fMask]*3, fmaskY2dTEB=[fMask]*3, fmaskKappa=fMaskK,
decRight = dec + width / 2. fieldCoords = (raLeft, decLeft, raRight, decRight) smap = lm.makeEmptyCEATemplateAdvanced(*fieldCoords, pixScaleXarcmin=pixScale, pixScaleYarcmin=pixScale) smap.loadDataFromHealpixMap(hpPlanck, hpCoords="GALACTIC") stamp = smap.data.copy() / tfact stamp = zoom(stamp, zoom=(float(Np) / stamp.shape[0], float(Np) / stamp.shape[1])) #print ra, dec, stamp.shape if i == 1: lxMap, lyMap, modLMap, angMap, lx, ly = fmaps.getFTAttributesFromLiteMap( smap) xMap, yMap, modRMap, xx, yy = fmaps.getRealAttributes(smap) polCombList = ["TT"] Ny, Nx = stamp.shape win = fmaps.initializeCosineWindowData(Ny, Nx, lenApod=40, pad=5) #win = 1. w2 = np.mean(win**2.) fwhm = 5.0 tht_fwhm = np.deg2rad(fwhm / 60.) l = np.arange(0., 10000.) beamells = np.exp(-(tht_fwhm**2.) * (l**2.) / (8. * np.log(2.))) beamTemplate = fmaps.makeTemplate(l, beamells, modLMap) #print beamTemplate.shape
import flipper.liteMap as lm from enlib.fft import fft, ifft from numpy.fft import fftshift, ifftshift from enlib.resample import resample_fft, resample_bin arcX = 20 * 60. arcY = 10 * 60. arc = 10. * 60. px = 0.5 pxDn = 7.5 fineTemplate = lm.makeEmptyCEATemplate(arcX / 60., arcY / 60., pixScaleXarcmin=px, pixScaleYarcmin=px) lxMap, lyMap, modLMap, thetaMap, lx, ly = fmaps.getFTAttributesFromLiteMap( fineTemplate) xMap, yMap, modRMap, xx, yy = fmaps.getRealAttributes(fineTemplate) # sigArc = 3.0 # sig = sigArc*np.pi/180./60. # fineTemplate.data = np.exp(-modRMap**2./2./sig**2.) import btip.inpaintStamp as inp ell, Cl = np.loadtxt("../btip/data/cltt_lensed_Feb18.txt", unpack=True) ell, Cl = inp.total_1d_power(ell, Cl, ellmax=modLMap.max(), beamArcmin=1.4, noiseMukArcmin=12.0, TCMB=2.7255e6)
def main(argv): # Read some parameters from the ini file config = ConfigParser.SafeConfigParser() config.read("input/general.ini") fileRoot = config.get('sims', 'root_location') + config.get( 'sims', 'sim_root') savePath = config.get('sims', 'root_location') + "output/" istart = config.getint('sims', 'istart') iend = config.getint('sims', 'iend') widthArcmin = config.getfloat('cutouts', 'widthArcmin') pixScaleArcmin = config.getfloat('sims', 'pixScaleArcmin') npixx = int(widthArcmin / pixScaleArcmin / 2.) npixy = int(widthArcmin / pixScaleArcmin / 2.) stackTot = 0. # stack on lensed cmb + sz stackSZ = 0. # stack on sz stackDx = 0. # stack on deflection_x stackDy = 0. # stack on deflection_y stackKappa = 0. # stack on kappa = div.Deflection / 2 stackAlt = 0. # stack on kappa = div.Deflection / 2 calculated with FFTs stackEst = 0. # stack on kappa reconstruction totnum = 0 # total number of stamps read skip = 0 # number skipped because stamp falls outside edges for i in range(istart, iend + 1): froot = fileRoot + str(i).zfill(3) # read catalog of clusters and make a selection on mass catFile = froot + ".txt" xcens, ycens, m200s = np.loadtxt(catFile, unpack=True, usecols=[1, 2, 6]) selection = m200s > 1.e14 # open cmb map imgFile = froot + "_tSZ_MOD.fits" print "Loading fits file ", i, "with ", len( xcens[selection]), " clusters ..." hd = pyfits.open(imgFile) # open kappa reconstruction and apply a dumb correction to the pixel scale lmap = lm.liteMapFromFits(savePath + "kappa" + str(i).zfill(3) + ".fits") px = np.abs(lmap.x1-lmap.x0)/lmap.Nx*np.pi/180.\ *np.cos(np.pi/180.*0.5*(lmap.y0+lmap.y1))*180./np.pi*60. lmap.pixScaleX = px / 180. * np.pi / 60. print "pixel scale arcminutes X , ", lmap.pixScaleX * 180. * 60. / np.pi print "pixel scale arcminutes X , ", lmap.pixScaleY * 180. * 60. / np.pi tot = hd[0].data sz = hd[6].data + hd[7].data unl = hd[3].data dx = hd[8].data * np.pi / 180. / 60. dy = hd[9].data * np.pi / 180. / 60. pl = Plotter() pl.plot2d(dx) pl.done("dx.png") pl = Plotter() pl.plot2d(dy) pl.done("dy.png") kappa = 0.5 * (np.gradient(dx, axis=0) + np.gradient(dy, axis=1)) pl = Plotter() pl.plot2d(kappa) pl.done("rkappa.png") diffmap = tot - sz - unl #alt kappa import orphics.analysis.flatMaps as fmaps lxMap, lyMap, modLMap, thetaMap, lx, ly = fmaps.getFTAttributesFromLiteMap( lmap) win = fmaps.initializeCosineWindow(lmap, lenApod=100, pad=10) Ny = lmap.Ny kgradx = lx * fft2(dy * win) * 1j kgrady = ly.reshape((Ny, 1)) * fft2(dx * win) * 1j altkappa = 0.5 * ifft2(kgradx + kgrady).real saveMap = lmap.copy() saveMap.data = altkappa saveMap.writeFits(savePath + "inputKappa" + str(i).zfill(3) + ".fits", overWrite=True) pl = Plotter() pl.plot2d(altkappa) pl.done("fkappa.png") if i == 0: pl = Plotter() pl.plot2d(diffmap * win) pl.done("diff.png") #sys.exit() bigY, bigX = tot.shape print "Map area ", bigX * bigY * pixScaleArcmin * pixScaleArcmin / 60. / 60., " sq. deg." doRandom = False if doRandom: xlbound = xcens[selection].min() xrbound = xcens[selection].max() ylbound = ycens[selection].min() yrbound = ycens[selection].max() for xcen, ycen, m200 in zip(xcens[selection], ycens[selection], m200s[selection]): totnum += 1 if doRandom: xcen = np.random.randint(xlbound, xrbound) ycen = np.random.randint(ylbound, yrbound) else: xcen = int(xcen) ycen = int(ycen) if ycen - npixy < 0 or xcen - npixx < 0 or ycen + npixy > ( bigY - 1) or xcen + npixx > (bigX - 1): skip += 1 continue cutOutTot = tot[(ycen - npixy):(ycen + npixy), (xcen - npixx):(xcen + npixx)] cutOutSZ = sz[(ycen - npixy):(ycen + npixy), (xcen - npixx):(xcen + npixx)] cutOutDx = dx[(ycen - npixy):(ycen + npixy), (xcen - npixx):(xcen + npixx)] cutOutDy = dy[(ycen - npixy):(ycen + npixy), (xcen - npixx):(xcen + npixx)] cutOutKappa = kappa[(ycen - npixy):(ycen + npixy), (xcen - npixx):(xcen + npixx)] cutOutAlt = altkappa[(ycen - npixy):(ycen + npixy), (xcen - npixx):(xcen + npixx)] cutOutEst = lmap.data[(ycen - npixy):(ycen + npixy), (xcen - npixx):(xcen + npixx)] stackTot += cutOutTot stackSZ += cutOutSZ stackDx += cutOutDx stackDy += cutOutDy stackKappa += cutOutKappa stackAlt += cutOutAlt stackEst += cutOutEst print "Percentage near bounds = ", skip * 100. / totnum, " %" if doRandom: rs = "R" else: rs = "" N = totnum - skip stackD = np.sqrt(stackDx**2. + stackDy**2.) pl = Plotter() pl.plot2d(stackD / N) pl.done("plots/stackD" + rs + ".png") pl = Plotter() pl.plot2d(stackKappa / N) pl.done("plots/stackK" + rs + ".png") pl = Plotter() pl.plot2d(stackAlt / N) pl.done("plots/stackA" + rs + ".png") pl = Plotter() pl.plot2d(stackTot / N) pl.done("plots/stackTot" + rs + ".png") pl = Plotter() pl.plot2d(stackSZ / N) pl.done("plots/stackSZ" + rs + ".png") pl = Plotter() pl.plot2d(stackEst / N) pl.done("plots/stackE" + rs + ".png")
# self.data = np.asarray(0.).reshape(-1) # def copy(self): # tempCopy = template() # tempCopy.Ny,tempCopy.Nx = self.Ny,self.Nx # tempCopy.pixScaleY,tempCopy.pixScaleX = self.pixScaleY,self.pixScaleX # return tempCopy templateLM = template() templateLM.Ny, templateLM.Nx = thetaMapDown.shape Ny, Nx = thetaMapDown.shape templateLM.pixScaleY, templateLM.pixScaleX = thetaMapDown.pixshape() from orphics.analysis import flatMaps as fmaps from alhazen.quadraticEstimator import Estimator lxMap, lyMap, modLMap, angMap, lx, ly = fmaps.getFTAttributesFromLiteMap( templateLM) pol = False if pol: #polCombList = ["TT","ET","EB"] polCombList = ["EB"] shape = (3, ) + shape else: polCombList = ["TT"] # simRoot1 = "/astro/astronfs01/workarea/msyriac/cmbSims/" # beamPath = simRoot1 + "beam_0.txt" # l,beamells = np.loadtxt(beamPath,unpack=True,usecols=[0,1]) fwhm = 1.0 tht_fwhm = np.deg2rad(fwhm / 60.)
def NFWMatchedFilterSN(clusterCosmology,log10Moverh,c,z,ells,Nls,kellmax,overdensity=500.,critical=True,atClusterZ=True,arcStamp=100.,pxStamp=0.05,saveId=None,verbose=False,rayleighSigmaArcmin=None,returnKappa=False,winAtLens=None): if rayleighSigmaArcmin is not None: assert rayleighSigmaArcmin>=pxStamp M = 10.**log10Moverh lmap = lm.makeEmptyCEATemplate(raSizeDeg=arcStamp/60., decSizeDeg=arcStamp/60.,pixScaleXarcmin=pxStamp,pixScaleYarcmin=pxStamp) kellmin = 2.*np.pi/arcStamp*np.pi/60./180. xMap,yMap,modRMap,xx,yy = fmaps.getRealAttributes(lmap) lxMap,lyMap,modLMap,thetaMap,lx,ly = fmaps.getFTAttributesFromLiteMap(lmap) cc = clusterCosmology cmb = False if winAtLens is None: cmb = True comS = cc.results.comoving_radial_distance(cc.cmbZ)*cc.h comL = cc.results.comoving_radial_distance(z)*cc.h winAtLens = (comS-comL)/comS kappaReal, r500 = NFWkappa(cc,M,c,z,modRMap*180.*60./np.pi,winAtLens,overdensity=overdensity,critical=critical,atClusterZ=atClusterZ) dAz = cc.results.angular_diameter_distance(z) * cc.h th500 = r500/dAz #fiveth500 = 10.*np.pi/180./60. #5.*th500 fiveth500 = 5.*th500 # print "5theta500 " , fiveth500*180.*60./np.pi , " arcminutes" # print "maximum theta " , modRMap.max()*180.*60./np.pi, " arcminutes" kInt = kappaReal.copy() kInt[modRMap>fiveth500] = 0. # print "mean kappa inside theta500 " , kInt[modRMap<fiveth500].mean() # print "area of th500 disc " , np.pi*fiveth500**2.*(180.*60./np.pi)**2. # print "estimated integral " , kInt[modRMap<fiveth500].mean()*np.pi*fiveth500**2. k500 = simps(simps(kInt, yy), xx) if verbose: print "integral of kappa inside disc ",k500 kappaReal[modRMap>fiveth500] = 0. #### !!!!!!!!! Might not be necessary! # if cmb: print z,fiveth500*180.*60./np.pi Ukappa = kappaReal/k500 # pl = Plotter() # pl.plot2d(Ukappa) # pl.done("output/kappa.png") ellmax = kellmax ellmin = kellmin Uft = fftfast.fft(Ukappa,axes=[-2,-1]) if rayleighSigmaArcmin is not None: Prayleigh = rayleigh(modRMap*180.*60./np.pi,rayleighSigmaArcmin) outDir = "/gpfs01/astro/www/msyriac/plots/" # io.quickPlot2d(Prayleigh,outDir+"rayleigh.png") rayK = fftfast.fft(ifftshift(Prayleigh),axes=[-2,-1]) rayK /= rayK[modLMap<1.e-3] Uft = Uft.copy()*rayK Upower = np.real(Uft*Uft.conjugate()) # pl = Plotter() # pl.plot2d(fftshift(Upower)) # pl.done("output/upower.png") Nls[Nls<0.]=0. s = splrep(ells,Nls,k=3) Nl2d = splev(modLMap,s) Nl2d[modLMap<ellmin]=np.inf Nl2d[modLMap>ellmax] = np.inf area = lmap.Nx*lmap.Ny*lmap.pixScaleX*lmap.pixScaleY Upower = Upower *area / (lmap.Nx*lmap.Ny)**2 filter = np.nan_to_num(Upower/Nl2d) #filter = np.nan_to_num(1./Nl2d) filter[modLMap>ellmax] = 0. filter[modLMap<ellmin] = 0. # pl = Plotter() # pl.plot2d(fftshift(filter)) # pl.done("output/filter.png") # if (cmb): print Upower.sum() # if not(cmb) and z>2.5: # bin_edges = np.arange(500,ellmax,100) # binner = bin2D(modLMap, bin_edges) # centers, nl2dells = binner.bin(Nl2d) # centers, upowerells = binner.bin(np.nan_to_num(Upower)) # centers, filterells = binner.bin(filter) # from orphics.tools.io import Plotter # pl = Plotter(scaleY='log') # pl.add(centers,upowerells,label="upower") # pl.add(centers,nl2dells,label="noise") # pl.add(centers,filterells,label="filter") # pl.add(ells,Nls,ls="--") # pl.legendOn(loc='upper right') # #pl._ax.set_ylim(0,1e-8) # pl.done("output/filterells.png") # sys.exit() varinv = filter.sum() std = np.sqrt(1./varinv) sn = k500/std if verbose: print sn if saveId is not None: np.savetxt("data/"+saveId+"_m"+str(log10Moverh)+"_z"+str(z)+".txt",np.array([log10Moverh,z,1./sn])) if returnKappa: return sn,fftfast.ifft(Uft,axes=[-2,-1],normalize=True).real*k500 return sn, k500, std
def getDLnMCMB(ells,Nls,clusterCosmology,log10Moverh,z,concentration,arcStamp,pxStamp,arc_upto,bin_width,expectedSN,Nclusters=1000,numSims=30,saveId=None,numPoints=1000,nsigma=8.,overdensity=500.,critical=True,atClusterZ=True): import flipper.liteMap as lm if saveId is not None: from orphics.tools.output import Plotter M = 10.**log10Moverh cc = clusterCosmology stepfilter_ellmax = max(ells) lmap = lm.makeEmptyCEATemplate(raSizeDeg=arcStamp/60., decSizeDeg=arcStamp/60.,pixScaleXarcmin=pxStamp,pixScaleYarcmin=pxStamp) xMap,yMap,modRMap,xx,xy = fmaps.getRealAttributes(lmap) lxMap,lyMap,modLMap,thetaMap,lx,ly = fmaps.getFTAttributesFromLiteMap(lmap) kappaMap,retR500 = NFWkappa(cc,M,concentration,z,modRMap*180.*60./np.pi,winAtLens,overdensity,critical,atClusterZ) finetheta = np.arange(0.01,arc_upto,0.01) finekappa,retR500 = NFWkappa(cc,M,concentration,z,finetheta,winAtLens,overdensity,critical,atClusterZ) kappaMap = fmaps.stepFunctionFilterLiteMap(kappaMap,modLMap,stepfilter_ellmax) generator = fmaps.GRFGen(lmap,ells,Nls) bin_edges = np.arange(0.,arc_upto,bin_width) binner = bin2D(modRMap*180.*60./np.pi, bin_edges) centers, thprof = binner.bin(kappaMap) if saveId is not None: pl = Plotter() pl.plot2d(kappaMap) pl.done("output/"+saveId+"kappa.png") expectedSNGauss = expectedSN*np.sqrt(numSims) sigma = 1./expectedSNGauss amplitudeRange = np.linspace(1.-nsigma*sigma,1.+nsigma*sigma,numPoints) lnLikes = 0. bigStamp = 0. for i in range(numSims): profiles,totstamp = getProfiles(generator,stepfilter_ellmax,kappaMap,binner,Nclusters) bigStamp += totstamp stats = getStats(profiles) if i==0 and (saveId is not None): pl = Plotter() pl.add(centers,thprof,lw=2,color='black') pl.add(finetheta,finekappa,lw=2,color='black',ls="--") pl.addErr(centers,stats['mean'],yerr=stats['errmean'],lw=2) pl._ax.set_ylim(-0.01,0.3) pl.done("output/"+saveId+"profile.png") pl = Plotter() pl.plot2d(totstamp) pl.done("output/"+saveId+"totstamp.png") Likes = getAmplitudeLikelihood(stats['mean'],stats['covmean'],amplitudeRange,thprof) lnLikes += np.log(Likes) width = amplitudeRange[1]-amplitudeRange[0] Likes = np.exp(lnLikes) Likes = Likes / (Likes.sum()*width) #normalize ampBest,ampErr = cfit(norm.pdf,amplitudeRange,Likes,p0=[1.0,0.5])[0] sn = ampBest/ampErr/np.sqrt(numSims) snAll = ampBest/ampErr if snAll<5.: print "WARNING: ", saveId, " run with mass ", M , " and redshift ", z , " has overall S/N<5. \ Consider re-running with a greater numSims, otherwise estimate of per Ncluster S/N will be noisy." if saveId is not None: Fit = np.array([np.exp(-0.5*(x-ampBest)**2./ampErr**2.) for x in amplitudeRange]) Fit = Fit / (Fit.sum()*width) #normalize pl = Plotter() pl.add(amplitudeRange,Likes,label="like") pl.add(amplitudeRange,Fit,label="fit") pl.legendOn(loc = 'lower left') pl.done("output/"+saveId+"like.png") pl = Plotter() pl.plot2d(bigStamp/numSims) pl.done("output/"+saveId+"bigstamp.png") np.savetxt("data/"+saveId+"_m"+str(log10Moverh)+"_z"+str(z)+".txt",np.array([log10Moverh,z,1./sn])) return 1./sn