def recon_from_config(Config,
recon_section,
parray,
theory,
lmax,
grad_cut=None,
pol=False,
u_equals_l=True):
min_ell = fmaps.minimum_ell(parray.shape, parray.wcs)
lb = ellbounds_from_config(Config, recon_section, min_ell)
tellmin = lb['tellminY']
tellmax = lb['tellmaxY']
pellmin = lb['pellminY']
pellmax = lb['pellmaxY']
kellmin = lb['kellmin']
kellmax = lb['kellmax']
lxmap_dat, lymap_dat, modlmap_dat, angmap_dat, lx_dat, ly_dat = fmaps.get_ft_attributes_enmap(
parray.shape, parray.wcs)
template_dat = fmaps.simple_flipper_template_from_enmap(
parray.shape, parray.wcs)
nT = parray.nT
nP = parray.nP
kbeam_dat = parray.lbeam
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,
modlmap_dat,
lmin=kellmin,
lmax=kellmax)
with oio.nostdout():
from alhazen.quadraticEstimator import Estimator
qest = Estimator(template_dat,
theory,
theorySpectraForNorm=None,
noiseX2dTEB=[nT, nP, nP],
noiseY2dTEB=[nT, nP, nP],
fmaskX2dTEB=[fMaskCMB_T, fMaskCMB_P, fMaskCMB_P],
fmaskY2dTEB=[fMaskCMB_T, fMaskCMB_P, fMaskCMB_P],
fmaskKappa=fMask,
kBeamX=kbeam_dat,
kBeamY=kbeam_dat,
doCurl=False,
TOnly=not (pol),
halo=True,
uEqualsL=u_equals_l,
gradCut=grad_cut,
bigell=lmax)
return tellmin, tellmax, pellmin, pellmax, kellmin, kellmax, qest
def _init_qests(self):
mlist = ['e','s','r']
self.qest = {}
tellminY = 500
tellmaxY = 3000
pellminY = 500
pellmaxY = 3000
tellminX = 500
tellmaxX = 3000
pellminX = 500
pellmaxX = 3000
kellmin = 80
kellmax = 3000
self.kellmin = kellmin
self.kellmax = kellmax
for m in mlist:
lxmap_dat,lymap_dat,modlmap_dat,angmap_dat,lx_dat,ly_dat = fmaps.get_ft_attributes_enmap(self.shape[m],self.wcs[m])
nT = modlmap_dat.copy()*0.
nP = modlmap_dat.copy()*0.
lbeam = modlmap_dat.copy()*0.+1.
template_dat = fmaps.simple_flipper_template_from_enmap(self.shape[m],self.wcs[m])
fMaskCMB_TX = fmaps.fourierMask(lx_dat,ly_dat,modlmap_dat,lmin=tellminX,lmax=tellmaxX)
fMaskCMB_TY = fmaps.fourierMask(lx_dat,ly_dat,modlmap_dat,lmin=tellminY,lmax=tellmaxY)
fMaskCMB_PX = fmaps.fourierMask(lx_dat,ly_dat,modlmap_dat,lmin=pellminX,lmax=pellmaxX)
fMaskCMB_PY = fmaps.fourierMask(lx_dat,ly_dat,modlmap_dat,lmin=pellminY,lmax=pellmaxY)
fMask = fmaps.fourierMask(lx_dat,ly_dat,modlmap_dat,lmin=kellmin,lmax=kellmax)
with io.nostdout():
self.qest[m] = Estimator(template_dat,
self.theory,
theorySpectraForNorm=None,
noiseX2dTEB=[nT,nP,nP],
noiseY2dTEB=[nT,nP,nP],
fmaskX2dTEB=[fMaskCMB_TX,fMaskCMB_PX,fMaskCMB_PX],
fmaskY2dTEB=[fMaskCMB_TY,fMaskCMB_PY,fMaskCMB_PY],
fmaskKappa=fMask,
kBeamX = lbeam,
kBeamY = lbeam,
doCurl=False,
TOnly=True,
halo=True,
uEqualsL=True,
gradCut=None,verbose=False,
bigell=self.lmax)
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)
gGenP2 = fmaps.GRFGen(lensedTLm.copy(), ellNoise, Npp, bufferFactor=1)
if noiseT > 1.e-3:
lensedTLm.data = lensedTLm.data + gGenT.getMap(stepFilterEll=None)
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,
modlmap_dat,
lmin=kellmin,
lmax=kellmax)
qest = Estimator(template_dat,
theory,
lmap.pixScaleX = px / 180. * np.pi / 60.
templateMap = lmap.copy()
lxMap, lyMap, modLMap, thetaMap, lx, ly = fmaps.getFTAttributesFromLiteMap(
templateMap)
window = fmaps.initializeCosineWindow(templateMap,
lenApod=tapWid,
pad=tapPad)
print "Making white noise..."
nT, nP = fmaps.whiteNoise2D([noiseT, noiseP],
beamArcmin,
modLMap,
TCMB=TCMB)
fMask = fmaps.fourierMask(lx, ly, modLMap, lmin=2, lmax=cmbellmax)
fMaskK = fmaps.fourierMask(lx, ly, modLMap, lmin=2, lmax=kellmax)
qest = Estimator(templateMap,
theory,
theorySpectraForNorm=None,
noiseX2dTEB=[nT, nP, nP],
noiseY2dTEB=[nT, nP, nP],
fmaskX2dTEB=[fMask] * 3,
fmaskY2dTEB=[fMask] * 3,
fmaskKappa=fMaskK,
doCurl=False,
TOnly=True,
halo=True,
gradCut=10000,
verbose=True)
clkk = theory.gCl('kk', ellrange)
lcltt = theory.lCl('TT', ellrange)
ucltt = theory.uCl('TT', ellrange)
# quadratic estimator
deg = 5.
px = 0.5
shape, wcs = enmap.get_enmap_patch(deg * 60., px, proj="car", pol=False)
template = fmaps.simple_flipper_template_from_enmap(shape, wcs)
lxmap_dat, lymap_dat, modlmap_dat, angmap_dat, lx_dat, ly_dat = fmaps.get_ft_attributes_enmap(
shape, wcs)
lbin_edges = np.arange(kellmin, kellmax, 200)
lbinner_dat = stats.bin2D(modlmap_dat, lbin_edges)
fmask = fmaps.fourierMask(lx_dat,
ly_dat,
modlmap_dat,
lmin=kellmin,
lmax=kellmax)
nlgen = qe.NlGenerator(template, theory)
nTX, nPX, nTY, nPY = nlgen.updateNoise(beamX=beam,
noiseTX=noiseT,
noisePX=0.,
tellminX=tellmin,
tellmaxX=tellmax,
pellminX=pellmin,
pellmaxX=pellmax)
nlgen.N.getNlkk2d('TT', halo=True)
nlkk0_2d = nlgen.N.Nlkk['TT']
cents, nlkk0 = lbinner_dat.bin(nlkk0_2d)
clkk2d = theory.gCl('kk', modlmap_dat)
zL,
modr_sim,
winAtLens,
overdensity=overdensity,
critical=critical,
atClusterZ=atClusterZ)
phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True)
alpha_pix = enmap.grad_pixf(fphi)
grad_phi_true = enmap.grad(phi)
res_stack = 0.
fMaskCMB_T = fmaps.fourierMask(lx_sim,
ly_sim,
modlmap_sim,
lmin=tellmin,
lmax=tellmax)
# io.quickPlot2d(np.fft.fftshift(fMaskCMB_T),out_dir+"presmooth.png")
# fMaskCMB_T = fmaps.smooth(fMaskCMB_T,modlmap_sim,gauss_sigma_arcmin=0.1)
# io.quickPlot2d(np.fft.fftshift(fMaskCMB_T),out_dir+"postsmooth.png")
# fMaskCMB_T[modlmap_sim<2]=0.
def f(rmap):
fk = fftfast.fft(rmap, axes=[-2, -1])
fk = np.nan_to_num(fk) * fMaskCMB_T
return enmap.samewcs(
fftfast.ifft(fk, axes=[-2, -1], normalize=True).real, rmap)
