def obtain_1string_map(fwhm=1.4, string_map_file=STRING_MAP_FILE,
map_fov_deg=7.2,
beam_smear=True, Gmu=1.4e-7):
Tcmb_uK = 2.72548*1e6
deg2rad = np.pi/180.
string_map = liteMap.liteMapFromFits(string_map_file)
string_map.data *= Gmu * Tcmb_uK
string_map.area = map_fov_deg**2.
string_map.Nx, string_map.Ny = np.shape(string_map.data)
string_map.x0 = 0.
string_map.y0 = 0.
string_map.x1 = map_fov_deg
string_map.y1 = map_fov_deg
string_map.pixScaleX = deg2rad * map_fov_deg / string_map.Nx #this is in rad
string_map.pixScaleY = deg2rad * map_fov_deg / string_map.Ny #this is in rad
if beam_smear:
string_map = string_map.convolveWithGaussian(fwhm=fwhm)
gradx,grady = np.gradient(string_map.data,string_map.pixScaleX,string_map.pixScaleY)
gradmap = np.sqrt(gradx**2 + grady**2)
gradx,grady = np.gradient(gradmap,string_map.pixScaleX,string_map.pixScaleY)
gradgradmap = np.sqrt(gradx**2 + grady**2)
return string_map.data, gradmap, gradgradmap
def use4way_for_2way(self, fourwayfiles):
"""A kludge to average 4way maps 0+1 and 2+3 to emulate a 2-way split."""
print "Kludge: using 4-ways as if 2-ways"
assert len(fourwayfiles) == 4
maps = [liteMap.liteMapFromFits(f) for f in fourwayfiles]
weightfiles = [f.replace("1000", "weights") for f in fourwayfiles]
wts = [liteMap.liteMapFromFits(f) for f in weightfiles]
m1 = maps[0].copy()
m2 = maps[2].copy()
m1.data = (maps[0].data + maps[2].data) * 0.5
m2.data = (maps[1].data + maps[3].data) * 0.5
# Do a weighted sum
w = [count.data for count in wts]
# m1.data[::] = ((maps[1].data*w[1] + maps[2].data*w[2])/(w[1]+w[2]))[::]
# m2.data[::] = ((maps[0].data*w[0] + maps[3].data*w[3])/(w[0]+w[3]))[::]
return [m1, m2]
def __init__(
self,
existingSkyMap=None,
mapfile=DEFAULT.map,
weightfile=DEFAULT.weight,
twowayfiles=DEFAULT.twoway,
trim=True,
raRange=[0, 105],
decRange=[-56, -50.33],
cal_correction=1.0,
):
if existingSkyMap:
for a in ("map", "fmap", "wt", "twoway", "ftwoway", "sensmap", "diff"):
try:
self.__dict__[a] = existingSkyMap.__dict__[a]
except KeyError:
pass
return
map = liteMap.liteMapFromFits(mapfile)
wt = liteMap.liteMapFromFits(weightfile)
if len(twowayfiles) == 4:
twoway = self.use4way_for_2way(twowayfiles)
else:
twoway = [liteMap.liteMapFromFits(f) for f in twowayfiles]
if trim:
map = map.selectSubMap(raRange[0], raRange[1], decRange[0], decRange[1])
wt = wt.selectSubMap(raRange[0], raRange[1], decRange[0], decRange[1])
twoway = [tw.selectSubMap(raRange[0], raRange[1], decRange[0], decRange[1]) for tw in twoway]
print "Applying calibration factor", cal_correction
map.data *= cal_correction
for t in twoway:
t.data *= cal_correction
self.map = map
self.wt = wt
self.twoway = twoway
self.fmap = self.ftwoway = self.sensmap = self.diff = None # will computer later
kappa = qest.getKappa('TT')
kappa = kappa - kappa.mean()
if k == 0:
pl = Plotter()
pl.plot2d(kappa.real)
pl.done("kappa.png")
#meanfield = kappa.real.copy()*0.
w2 = np.mean(window**2.)
templateMap.data = kappa.real / w2
templateMap.writeFits(savePath + "kappa" + str(i).zfill(3) + ".fits",
overWrite=True)
lmap1 = lm.liteMapFromFits(savePath + "inputKappa" + str(i).zfill(3) +
".fits")
if k == 0:
pl = Plotter()
pl.plot2d(lmap1.data)
pl.done("inkappa.png")
px = np.abs(lmap1.x1-lmap1.x0)/lmap1.Nx*np.pi/180.\
*np.cos(np.pi/180.*0.5*(lmap1.y0+lmap1.y1))*180./np.pi*60.
print px
lmap1.pixScaleX = px / 180. * np.pi / 60.
lmap1.data = lmap1.data * window
w4 = np.mean(window**4.)
def downWriteMap(fname):
nowMap = lm.liteMapFromFits(fname)
lowTemp = lm.getEmptyMapWithDifferentDims(nowMap, int(nowMap.Ny / 2.),
int(nowMap.Nx / 2.))
lowMap = lm.resampleFromHiResMap(nowMap, lowTemp)
lowMap.writeFits(fname[:-5] + "_down.fits", overWrite=True)
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")
def main(argv):
iniFile = 'input/noise.ini'
config = ConfigParser()
config.read(iniFile)
mass = 1.E14
conc = 3.0
z = 1.0
#noiseT = 1.0
#beam = 5.0
#ellbeam = 7000.
Nclus = 1000.
arcupto = 10.
mss = []
#beams = np.arange(1.0,7.0,0.1)
beams = [float(argv[0])]
noiseT = float(argv[1])
xy = argv[2]
print beams
#sys.exit()
for beam in beams:
ellbeam = 7000
#ellbeam = int(np.sqrt(8.*np.log(2.)) / beam *60. * 180./np.pi)
print "Ellbeam, ", ellbeam
Nsupp = 10000.
px = 0.1
arc = 20.
#xy = 'TT'
bin_width = 10 #int(beam/px)
Nreals = 5000
Nbins = int(arcupto/bin_width)
scale = px
thetas = np.arange(bin_width*scale/2.,arcupto,scale*bin_width)
lensedClFile = "../cmb-lensing-projections/data/TheorySpectra/ell28k_highacc_lensedCls.dat"
unlensedClFile = "../cmb-lensing-projections/data/TheorySpectra/ell28k_highacc_scalCls.dat"
cmbells,cltt,clee,clbb,clte = Lens.loadCls(lensedClFile)
ucmbells,ucltt,uclee,uclte,dummy = Lens.loadCls(unlensedClFile)
uclbb = clbb.copy()[:len(ucmbells)]
uClsNow = [ucltt,uclee,uclbb,uclte]
uClsFid = [ucltt,uclee,uclbb,uclte]
lClsFid = [cltt,clee,clbb,clte]
template = "../DerivGen/data/order5_lensedCMB_T_beam_cutout_3.fits"
templateMap = liteMap.liteMapFromFits(template)
Lens.makeBinfile("../cmb-lensing-projections/data/bintemp.dat",first=2,last=9000,width=20)
lmin = 2.
lmax = 8000.
if xy=='mv':
NormGen = Lens.AL(templateMap,'TT',ucmbells,uClsNow,ucmbells,uClsFid,cmbells,lClsFid,lmax,lmax,gradCut=2000.)
NormGen.addWhiteNoise(noiseT,np.sqrt(2.)*noiseT,beam,(0,0,lmin,lmax),(lmin,lmax,lmin,lmax))
L1,Nl1,ph = NormGen.binnedNLkk("../cmb-lensing-projections/data/bintemp.dat",inverted=False,halo=True)
NormGen = Lens.AL(templateMap,'EB',ucmbells,uClsNow,ucmbells,uClsFid,cmbells,lClsFid,lmax,lmax,gradCut=2000.)
NormGen.addWhiteNoise(noiseT,np.sqrt(2.)*noiseT,beam,(0,0,lmin,lmax),(lmin,lmax,lmin,lmax))
L2,Nl2,ph = NormGen.binnedNLkk("../cmb-lensing-projections/data/bintemp.dat",inverted=False,halo=True)
assert np.all(L1==L2)
L = L1.copy()
Nl = 1./(1./Nl1+1./Nl2)
else:
NormGen = Lens.AL(templateMap,xy,ucmbells,uClsNow,ucmbells,uClsFid,cmbells,lClsFid,lmax,lmax,gradCut=2000.)
NormGen.addWhiteNoise(noiseT,np.sqrt(2.)*noiseT,beam,(0,0,lmin,lmax),(lmin,lmax,lmin,lmax))
L,Nl,ph = NormGen.binnedNLkk("../cmb-lensing-projections/data/bintemp.dat",inverted=False,halo=True)
pl = Plotter(scaleX='log',scaleY='log')
pl.add(L,Nl)
pl.done('stampNl.png')
#sys.exit()
rads = []
print "Making stamps to determine profile covmat..."
for i in range(Nreals):
#print i
lm = liteMap.makeEmptyCEATemplate(raSizeDeg=arc/60., decSizeDeg=arc/60.,pixScaleXarcmin = px, pixScaleYarcmin=px)
if i==0:
#print lm.data.shape
Npix = lm.data.shape[0]
lfilt = stepFunctionFilterFromLiteMap(lm,ellbeam)
kapmaker = kappaMaker(Cosmology(defaultLCDM),mass,conc,z,storeKap=False)
kapstamp,kaprad = kapmaker.getKappaAndProfile(Npix,scale=px,beam=None,bin_width=bin_width)
# pl = Plotter()
# pl.plot2d(kapstamp)
# pl.done('kappa.png')
# sys.exit()
lm.fillWithGaussianRandomField(L,Nl/Nsupp,bufferFactor = 1)
stamp = lm.data.copy()
stamp = stamp+kapstamp.copy()
stamp = np.nan_to_num(filterDataFromTemplate(stamp,lfilt))
prof = radial_data(stamp,annulus_width=bin_width).mean
#print prof
rads.append(prof)
if i%1000==0: print i
radmeans, covMean, cov, errMean,err,corrcoef = getStats(rads,Nreals)
thstamp = np.nan_to_num(filterDataFromTemplate(kapstamp,lfilt))
thprof = radial_data(thstamp,annulus_width=bin_width).mean
siginv = np.linalg.pinv(cov[:len(thetas),:len(thetas)])
#print siginv
#print radmeans[:len(thetas)]
b = np.dot(siginv,radmeans[:len(thetas)])
chisq = np.dot(radmeans[:len(thetas)],b)
print np.sqrt(chisq*Nclus/Nsupp)
#print radmeans
#print err
pl = Plotter()
pl.addErr(thetas,radmeans[:len(thetas)],yerr=err[:len(thetas)])
pl.add(thetas,kapmaker.kappa(thetas))
pl._ax.set_ylim(-0.01,0.25)
pl._ax.set_xlim(0.0,arcupto)
pl.done('profile.png')
pl = Plotter()
pl.plot2d(corrcoef)
pl.done('corrcoef.png')
pl = Plotter()
pl.plot2d(stamp)
pl.done('stamp.png')
amplitudeRange = np.arange(-1.,2.,0.01)
width = amplitudeRange[1]-amplitudeRange[0]
amplist = []
print "Fitting amplitudes..."
for i in range(Nreals):
prof = rads[i][:len(thetas)]
Likelihood = lambda x: np.exp(-0.5*fchisq(prof,siginv,thprof[:len(thetas)],amp=x))
Likes = np.array([Likelihood(x) for x in amplitudeRange])
Likes = Likes / (Likes.sum()*width) #normalize
ampBest,ampErr = cfit(norm.pdf,amplitudeRange,Likes,p0=[1.0,0.5])[0]
#print ampBest,ampErr
amplist.append(ampBest)
ms = plotstat( -1.,2.,0.01 , (np.array(amplist)) , "amps",fit=True,scale=np.sqrt(Nclus/Nsupp))
mss.append(ms)
pl = Plotter()
pl.add(beams,mss)
pl.done('beam.png')
np.savetxt("output/m1beamsms"+xy+argv[0]+"_noise"+str(noiseT)+".txt",np.vstack((beams,mss)).transpose())
from __future__ import division, print_function
import numpy as np
from scipy.stats import moment
import matplotlib.pyplot as plt
import liteMap
import fftTools
from flipper import *
STRING_MAP_FILE = '/data/verag/strings/inputs/dTmap_stg_Dcmb0000.fits'#'/Users/verag/Research/strings/strings/data/dTmap_stg_Dcmb0000.fits'
string_template = liteMap.liteMapFromFits(STRING_MAP_FILE)
string_template.Nx, string_template.Ny = np.shape(string_template.data)
string_fovX = 7.2 #deg
string_fovY = 7.2 #deg
string_scaleX = np.deg2rad(string_fovX) / string_template.Nx
string_scaleY = np.deg2rad(string_fovY) / string_template.Ny
class Statistic(object):
def __init__(self, function, name):
"""function takes map data in, spits out number or array
"""
self.function = function
self.name = name
def __call__(self, data, **kwargs):
return self.function(data, **kwargs)
class Moments(Statistic):
def __init__(self, moments=[2,3,4], name='moments'):
self.moments = moments
def obtain_N_cmb_maps(fwhm=1.4, string_file_num=0,
spectra_file=SPECTRA_FILE, map_fov_deg=7.2,
return_strings=False,
beam_smear=True, Nmaps=1, Gmu=0.,
noise=16, Nx=None, Ny=None):
if string_file_num < 10:
string_map_file = '/data/verag/strings/inputs/dTmap_stg_Dcmb000{}.fits'.format(string_file_num) # this can be 0-9
else:
string_map_file = '/data/verag/strings/inputs/dTmap_stg_Dcmb00{}.fits'.format(string_file_num) # this can be 0-9
maps = []
maps_stringy = []
Tcmb_uK = 2.72548*1e6
deg2rad = np.pi/180.
string_map = liteMap.liteMapFromFits(string_map_file)
string_map.data *= Gmu * Tcmb_uK
string_map.area = map_fov_deg**2.
string_map.Nx, string_map.Ny = np.shape(string_map.data)
string_map.x0 = 0.
string_map.y0 = 0.
string_map.x1 = map_fov_deg
string_map.y1 = map_fov_deg
string_map.pixScaleX = deg2rad * map_fov_deg / string_map.Nx #this is in rad
string_map.pixScaleY = deg2rad * map_fov_deg / string_map.Ny #this is in rad
if Gmu>0:
if beam_smear:
string_map = string_map.convolveWithGaussian(fwhm=fwhm)
cmb_map = string_map.copy()
if Nx is not None:
cmb_map.Nx = Nx
if Ny is not None:
cmb_map.Ny = Ny
cmb_map.data = np.zeros((cmb_map.Nx,cmb_map.Ny))
cmb_map.pixScaleX = deg2rad * map_fov_deg / cmb_map.Nx #this is in rad
cmb_map.pixScaleY = deg2rad * map_fov_deg / cmb_map.Ny #this is in rad
spectra = np.loadtxt(spectra_file)
ls = spectra[:,0]
cl = spectra[:,1]/(ls*(ls + 1))*2.*np.pi
for i in np.arange(Nmaps):
logging.info('{} of {}'.format(i+1, Nmaps))
cmb_map.fillWithGaussianRandomField(ls,cl)
if beam_smear:
cmb_map = cmb_map.convolveWithGaussian(fwhm=fwhm)
noise_map = np.random.standard_normal(np.shape(cmb_map.data)) * (noise)
cmb = cmb_map.data + noise_map
maps.append(cmb - cmb.mean())
if Gmu>0:
stringycmb = cmb_map.data + noise_map + string_map.data
maps_stringy.append(stringycmb - stringycmb.mean())
if Gmu>0 and return_strings:
return maps_stringy
else:
return maps
matplotlib.use('Agg')
from astLib import astWCS, astCoords
import liteMap as lm
import ConfigParser
config = ConfigParser.SafeConfigParser()
config.read("input/general.ini")
savePath = config.get('sims', 'root_location') + "output/"
N = 38
for i in range(1, N + 1):
print i
lmap = lm.liteMapFromFits(savePath + "kappa" + str(i).zfill(3) + ".fits")
if i == 1:
mf = lmap.data * 0.
mf += lmap.data
mf = mf / (N - 1)
lmap = lm.liteMapFromFits(savePath + "kappa000.fits")
from orphics.tools.output import Plotter
pl = Plotter()
pl.plot2d(mf)
pl.done("mf.png")
pl = Plotter()
def getTaperedMap(lkk,clkk,templateMapLoc = "../DerivGen/data/order5_lensedCMB_T_beam_cutout_3.fits",bufferFactor=2,taperWidth = 120,jackknife=36):
# jackknife = (number of jackknife regions)
assert is_square(jackknife)
templateMap = liteMap.liteMapFromFits(templateMapLoc)
templateMap.data[:,:] = 0.
templateMap.fillWithGaussianRandomField(lkk,clkk,bufferFactor = bufferFactor)
retMap = templateMap.copy()
xa,xb = (templateMap.x0,templateMap.x1)
ya,yb = (templateMap.y0,templateMap.y1)
x0 = min(xa,xb)
x1 = max(xa,xb)
y0 = min(ya,yb)
y1 = max(ya,yb)
xl = x1-x0
yl = y1-y0
Neach = int(np.sqrt(jackknife))
xeach = xl/Neach
yeach = yl/Neach
bufferx = 0.001
buffery = 0.001
smaps = []
stapers = []
for i in range(Neach):
tx0 = x0+i*xeach
tx1 = x0+(i+1)*xeach
if i==0: tx0 += bufferx
if i==Neach-1: tx1 -= bufferx
for j in range(Neach):
ty0 = y0+j*yeach
ty1 = y0+(j+1)*yeach
if j==0: ty0 += buffery
if j==Neach-1: ty1 -= buffery
print((tx0,tx1,ty0,ty1))
smap = templateMap.selectSubMap(tx0,tx1,ty0,ty1, safe = False)
#print smap.info()
subtaper = lpol.initializeCosineWindow(smap,int(taperWidth/Neach),0)
smap.data[:] = smap.data[:]*subtaper.data[:]
pl = Plotter()
pl.plot2d(smap.data)
pl.done("kappa"+str(i)+str(j)+".png")
smaps.append(smap)
stapers.append(subtaper)
#sys.exit()
taper = lpol.initializeCosineWindow(retMap,taperWidth,0)
retMap.data[:] = retMap.data[:]*taper.data[:]
pl = Plotter()
pl.plot2d(templateMap.data)
pl.done("kappa.png")
return retMap,taper,smaps,stapers
