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