Esempio n. 1
0
def takeCurl(vecStampX, vecStampY, lxMap, lyMap):

    fX = fft(vecStampX, axes=[-2, -1])
    fY = fft(vecStampY, axes=[-2, -1])

    return ifft((lxMap * fY - lyMap * fX) * 1j, axes=[-2, -1],
                normalize=True).real
Esempio n. 2
0
def TQUtoFourierTEB(T_map, Q_map, U_map, modLMap, angLMap):

    fT = fft(T_map, axes=[-2, -1])
    fQ = fft(Q_map, axes=[-2, -1])
    fU = fft(U_map, axes=[-2, -1])

    fE = fT.copy()
    fB = fT.copy()
    fE[:] = fQ[:] * np.cos(2. * angLMap) + fU * np.sin(2. * angLMap)
    fB[:] = -fQ[:] * np.sin(2. * angLMap) + fU * np.cos(2. * angLMap)

    return (fT, fE, fB)
Esempio n. 3
0
def smooth(data, modLMap, gauss_sigma_arcmin):
    kMap = fft(data, axes=[-2, -1])
    sigma = np.deg2rad(gauss_sigma_arcmin / 60.)
    beamTemplate = np.nan_to_num(1. / np.exp(
        (sigma**2.) * (modLMap**2.) / (2.)))
    kMap[:, :] = np.nan_to_num(kMap[:, :] * beamTemplate[:, :])
    return ifft(kMap, axes=[-2, -1], normalize=True).real
Esempio n. 4
0
	def __call__(self, x):
		xmap = self.dof.unzip(x)
		res  = xmap*0
		for info in self.infos:
			t  = [time.time()]
			work  = xmap*info.H
			t.append(time.time())
			umap  = info.U.apply(work)
			t.append(time.time())
			fmap  = fft.fft(umap+0j, axes=[-2,-1])
			t.append(time.time())
			fmap  = info.N.apply(fmap, exp=0.5)
			t.append(time.time())
			if info.W is not None:
				fmap = info.W.apply(fmap)
			t.append(time.time())
			fmap  = info.N.apply(fmap, exp=0.5)
			t.append(time.time())
			umap  = fft.ifft(fmap, umap+0j, axes=[-2,-1], normalize=True).real
			t.append(time.time())
			work = enmap.samewcs(info.U.trans(umap, work),work)
			t.append(time.time())
			work *= info.H
			t.append(time.time())
			t = np.array(t)
			print " %4.2f"*(len(t)-1) % tuple(t[1:]-t[:-1])
			res  += work
		res = utils.allreduce(res,comm)
		return self.dof.zip(res)
Esempio n. 5
0
 def __call__(self, x):
     xmap = self.dof.unzip(x)
     res = xmap * 0
     for info in self.infos:
         t = [time.time()]
         work = xmap * info.H
         t.append(time.time())
         umap = info.U.apply(work)
         t.append(time.time())
         fmap = fft.fft(umap + 0j, axes=[-2, -1])
         t.append(time.time())
         fmap = info.N.apply(fmap, exp=0.5)
         t.append(time.time())
         if info.W is not None:
             fmap = info.W.apply(fmap)
         t.append(time.time())
         fmap = info.N.apply(fmap, exp=0.5)
         t.append(time.time())
         umap = fft.ifft(fmap, umap + 0j, axes=[-2, -1],
                         normalize=True).real
         t.append(time.time())
         work = enmap.samewcs(info.U.trans(umap, work), work)
         t.append(time.time())
         work *= info.H
         t.append(time.time())
         t = np.array(t)
         print " %4.2f" * (len(t) - 1) % tuple(t[1:] - t[:-1])
         res += work
     res = utils.allreduce(res, comm)
     return self.dof.zip(res)
Esempio n. 6
0
def l(cseed,kseed,returnk=False,index=None):
    cname = fout_dir+"lensed_covseed_"+str(args.covseed).zfill(3)+"_cmbseed_"+str(cseed).zfill(5)+"_kseed_"+str(kseed).zfill(5)+".hdf"
    if unlensed:
        seedroot = (covseed)*Nsets*Nsims
        lensedt = parray_dat.get_unlensed_cmb(seed=seedroot+cseed,scalar=False)
    else:
        lensedt = enmap.read_map(cname)[0] if polsims else enmap.read_map(cname)
    # -- add beam and noise if you want --
    if "noiseless" not in expf_name:
        assert index is not None
        if rank==0: print("Adding beam...")
        flensed = fftfast.fft(lensedt,axes=[-2,-1])
        flensed *= parray_dat.lbeam
        lensedt = fftfast.ifft(flensed,axes=[-2,-1],normalize=True).real
        if rank==0: print("Adding noise...")
        seedroot = (covseed+1)*Nsets*Nsims # WARNING: noise sims will be correlated with CMB from the next covseed
        nseed = seedroot+index
        noise = parray_dat.get_noise_sim(seed=nseed)
        if paper:
            cents, noise1d = lbinner.bin(power(noise)[0])
            mpibox.add_to_stats('noisett',noise1d)        
        lensedt += noise
        
    lensedt = enmap.ndmap(lensedt,wcs_dat)
    
    if returnk:
        kname = fout_dir+"kappa_covseed_"+str(args.covseed).zfill(3)+"_kseed_"+str(kseed).zfill(5)+".hdf"
        return lensedt,enmap.read_map(kname)
    else:
        return lensedt
Esempio n. 7
0
def takeGrad(stamp, lyMap, lxMap):

    f = fft(stamp, axes=[-2, -1])

    return ifft(lyMap * f * 1j, axes=[-2, -1],
                normalize=True).real, ifft(lxMap * f * 1j,
                                           axes=[-2, -1],
                                           normalize=True).real
Esempio n. 8
0
def stepFunctionFilterLiteMap(map2d, modLMap, ellMax, ellMin=None):

    kmap = fft(map2d.copy(), axes=[-2, -1])
    kmap[modLMap > ellMax] = 0.
    if ellMin is not None:
        kmap[modLMap < ellMin] = 0.

    retMap = ifft(kmap, axes=[-2, -1], normalize=True).real

    return retMap
Esempio n. 9
0
 def __init__(self, shape, inspec, scale, corrfun):
     freqs = np.abs(fft.fftfreq(shape[-2]) * scale)
     spec_full = utils.interpol(inspec, np.abs(freqs[None]))
     # Build our 2d noise spectrum. First get the stripy part.
     ps_stripe = np.tile(1 / spec_full[:, None], [1, shape[-1]])
     # Then get our common mode
     ps_cmode = fft.fft(corrfun * 1j, axes=[-2, -1])
     # Scale common mode to have the same DC level as the striping
     ps_cmode *= ps_stripe[0, 0] / ps_cmode[0, 0]
     ps_tot = ps_stripe + ps_cmode
     self.inv_ps = 1 / ps_tot
Esempio n. 10
0
	def apply(self, arr, inplace=False):
		# Because of our padding and multiplication by the hitcount
		# before this, we should be safely apodized, and can assume
		# periodic boundaries
		if not inplace: arr = np.array(arr)
		carr = arr.astype(complex)
		ft   = fft.fft(carr, axes=[-2,-1])
		ft  *= self.inv_ps
		carr = fft.ifft(ft, carr, axes=[-2,-1], normalize=True)
		arr  = carr.real
		return arr
Esempio n. 11
0
	def __init__(self, shape, inspec, scale, corrfun):
		freqs = np.abs(fft.fftfreq(shape[-2]) * scale)
		spec_full = utils.interpol(inspec, np.abs(freqs[None]))
		# Build our 2d noise spectrum. First get the stripy part.
		ps_stripe = np.tile(1/spec_full[:,None], [1,shape[-1]])
		# Then get our common mode
		ps_cmode  = fft.fft(corrfun*1j,axes=[-2,-1])
		# Scale common mode to have the same DC level as the striping
		ps_cmode *= ps_stripe[0,0]/ps_cmode[0,0]
		ps_tot    = ps_stripe + ps_cmode
		self.inv_ps = 1/ps_tot
Esempio n. 12
0
 def apply(self, arr, inplace=False):
     # Because of our padding and multiplication by the hitcount
     # before this, we should be safely apodized, and can assume
     # periodic boundaries
     if not inplace: arr = np.array(arr)
     carr = arr.astype(complex)
     ft = fft.fft(carr, axes=[-2, -1])
     ft *= self.inv_ps
     carr = fft.ifft(ft, carr, axes=[-2, -1], normalize=True)
     arr = carr.real
     return arr
Esempio n. 13
0
    def updateTEB_X(self,
                    T2DData,
                    E2DData=None,
                    B2DData=None,
                    alreadyFTed=False):
        '''
        Masking and windowing and apodizing and beam deconvolution has to be done beforehand!

        Maps must have units corresponding to those of theory Cls and noise power
        '''
        self._hasX = True

        self.kGradx = {}
        self.kGrady = {}

        lx = self.N.lxMap
        ly = self.N.lyMap

        if alreadyFTed:
            self.kT = T2DData
        else:
            self.kT = fft(T2DData, axes=[-2, -1])
        self.kGradx['T'] = lx * self.kT.copy() * 1j
        self.kGrady['T'] = ly * self.kT.copy() * 1j

        if E2DData is not None:
            if alreadyFTed:
                self.kE = E2DData
            else:
                self.kE = fft(E2DData, axes=[-2, -1])
            self.kGradx['E'] = 1.j * lx * self.kE.copy()
            self.kGrady['E'] = 1.j * ly * self.kE.copy()
        if B2DData is not None:
            if alreadyFTed:
                self.kB = B2DData
            else:
                self.kB = fft(B2DData, axes=[-2, -1])
            self.kGradx['B'] = 1.j * lx * self.kB.copy()
            self.kGrady['B'] = 1.j * ly * self.kB.copy()
Esempio n. 14
0
def resample_fft(d, n, axes=None):
    """Resample numpy array d via fourier-reshaping. Requires periodic data.
	n indicates the desired output lengths of the axes that are to be
	resampled. By the fault the last len(n) axes are resampled, but this
	can be controlled via the axes argument."""
    d = np.asanyarray(d)
    # Compute output lengths from factors if necessary
    n = np.atleast_1d(n)
    if axes is None: axes = np.arange(-len(n), 0)
    else: axes = np.atleast_1d(axes)
    if len(n) == 1: n = np.repeat(n, len(axes))
    else: assert len(n) == len(axes)
    assert len(n) <= d.ndim
    # Nothing to do?
    if np.all(d.shape[-len(n):] == n): return d
    # Use the simple version if we can. It has lower memory overhead
    if d.ndim == 2 and len(n) == 1 and (axes[0] == 1 or axes[0] == -1):
        return resample_fft_simple(d, n[0])
    # Perform the fourier transform
    fd = fft.fft(d, axes=axes)
    # Frequencies are 0 1 2 ... N/2 (-N)/2 (-N)/2+1 .. -1
    # Ex 0* 1 2* -1 for n=4 and 0* 1 2 -2 -1 for n=5
    # To upgrade,   insert (n_new-n_old) zeros after n_old/2
    # To downgrade, remove (n_old-n_new) values after n_new/2
    # The idea is simple, but arbitrary dimensionality makes it
    # complicated.
    norm = 1.0
    for ax, nnew in zip(axes, n):
        ax %= d.ndim
        nold = d.shape[ax]
        dn = nnew - nold
        if dn > 0:
            padvals = np.zeros(fd.shape[:ax] + (dn, ) + fd.shape[ax + 1:],
                               fd.dtype)
            spre = tuple([slice(None)] * ax + [slice(0, nold // 2)] +
                         [slice(None)] * (fd.ndim - ax - 1))
            spost = tuple([slice(None)] * ax + [slice(nold // 2, None)] +
                          [slice(None)] * (fd.ndim - ax - 1))
            fd = np.concatenate([fd[spre], padvals, fd[spost]], axis=ax)
        elif dn < 0:
            spre = tuple([slice(None)] * ax + [slice(0, nnew // 2)] +
                         [slice(None)] * (fd.ndim - ax - 1))
            spost = tuple([slice(None)] * ax + [slice(nnew // 2 - dn, None)] +
                          [slice(None)] * (fd.ndim - ax - 1))
            fd = np.concatenate([fd[spre], fd[spost]], axis=ax)
        norm *= float(nnew) / nold
    # And transform back
    res = fft.ifft(fd, axes=axes, normalize=True)
    del fd
    res *= norm
    return res if np.issubdtype(d.dtype, np.complexfloating) else res.real
Esempio n. 15
0
    def updateTEB_Y(self,
                    T2DData=None,
                    E2DData=None,
                    B2DData=None,
                    alreadyFTed=False):
        assert self._hasX, "Need to initialize gradient first."
        self._hasY = True

        self.kHigh = {}

        if T2DData is not None:
            if alreadyFTed:
                self.kHigh['T'] = T2DData
            else:
                self.kHigh['T'] = fft(T2DData, axes=[-2, -1])
        else:
            self.kHigh['T'] = self.kT.copy()
        if E2DData is not None:
            if alreadyFTed:
                self.kHigh['E'] = E2DData
            else:
                self.kHigh['E'] = fft(E2DData, axes=[-2, -1])
        else:
            try:
                self.kHigh['E'] = self.kE.copy()
            except:
                pass

        if B2DData is not None:
            if alreadyFTed:
                self.kHigh['B'] = B2DData
            else:
                self.kHigh['B'] = fft(B2DData, axes=[-2, -1])
        else:
            try:
                self.kHigh['B'] = self.kB.copy()
            except:
                pass
Esempio n. 16
0
def deconvolveBeam(data,
                   modLMap,
                   beamTemplate,
                   lowPass=None,
                   returnFTOnly=False):

    kMap = fft(data, axes=[-2, -1])

    kMap[:, :] = (kMap[:, :] / beamTemplate[:, :])
    if lowPass is not None: kMap[modLMap > lowPass] = 0.
    if returnFTOnly:
        return kMap
    else:
        return ifft(kMap, axes=[-2, -1], normalize=True).real
Esempio n. 17
0
def downsample_fft_simple(d, factor=0.5, ngroup=100):
    """Resample 2d numpy array d via fourier-reshaping along
	last axis."""
    if factor == 1: return d
    nold = d.shape[1]
    nnew = int(nold * factor)
    res = np.zeros([d.shape[0], nnew], dtype=d.dtype)
    dn = nnew - nold
    for di in range(0, d.shape[0], ngroup):
        fd = fft.fft(d[di:di + ngroup])
        fd = np.concatenate([fd[:, :nnew / 2], fd[:, nnew / 2 - dn:]], 1)
        res[di:di + ngroup] = fft.ifft(fd, normalize=True).real
    del fd
    res *= factor
    return res
Esempio n. 18
0
def filter_map(data2d,
               filter2d,
               modLMap,
               lowPass=None,
               highPass=None,
               keep_mean=True):
    kMap = fft(data2d, axes=[-2, -1])
    if keep_mean:
        mean_val = kMap[modLMap < 1]

    kMap[:, :] = np.nan_to_num(kMap[:, :] * filter2d[:, :])
    if lowPass is not None: kMap[modLMap > lowPass] = 0.
    if highPass is not None: kMap[modLMap < highPass] = 0.

    if keep_mean: kMap[modLMap < 1] = mean_val
    return ifft(kMap, axes=[-2, -1], normalize=True).real
Esempio n. 19
0
def resample_fft(d, factors=[0.5], axes=None):
    """Resample numpy array d via fourier-reshaping. Requires periodic data.
	"factors" indicates the factors by which the axis lengths should be
	increased. If less factors are specified than the number of axes,
	the numbers apply to the last N axes, unless the "axes" argument
	is used to specify which ones."""
    if np.allclose(factors, 1): return d
    factors = np.atleast_1d(factors)
    assert len(factors) <= d.ndim
    if axes is None: axes = np.arange(-len(factors), 0)
    assert len(axes) == len(factors)
    if d.ndim == 2 and len(factors) == 1 and factors[0] < 1:
        return downsample_fft_simple(d, factors[0])
    fd = fft.fft(d, axes=axes)
    # Frequencies are 0 1 2 ... N/2 (-N)/2 (-N)/2+1 .. -1
    # Ex 0* 1 2* -1 for n=4 and 0* 1 2 -2 -1 for n=5
    # To upgrade,   insert (n_new-n_old) zeros after n_old/2
    # To downgrade, remove (n_old-n_new) values after n_new/2
    # The idea is simple, but arbitrary dimensionality makes it
    # complicated.
    for ax, factor in zip(axes, factors):
        ax %= d.ndim
        nold = d.shape[ax]
        nnew = int(nold * factor + 0.5)
        dn = nnew - nold
        if dn > 0:
            padvals = np.zeros(fd.shape[:ax] + (dn, ) + fd.shape[ax + 1:])
            spre = tuple([slice(None)] * ax + [slice(0, nold / 2)] +
                         [slice(None)] * (fd.ndim - ax - 1))
            spost = tuple([slice(None)] * ax + [slice(nold / 2, None)] +
                          [slice(None)] * (fd.ndim - ax - 1))
            fd = np.concatenate([fd[spre], padvals, fd[spost]], axis=ax)
        elif dn < 0:
            spre = tuple([slice(None)] * ax + [slice(0, nnew / 2)] +
                         [slice(None)] * (fd.ndim - ax - 1))
            spost = tuple([slice(None)] * ax + [slice(nnew / 2 - dn, None)] +
                          [slice(None)] * (fd.ndim - ax - 1))
            fd = np.concatenate([fd[spre], fd[spost]], axis=ax)
    # And transform back
    res = fft.ifft(fd, axes=axes, normalize=True)
    del fd
    res *= np.product(factors)
    return res if np.issubdtype(d.dtype, np.complexfloating) else res.real
Esempio n. 20
0
def resample_fft_simple(d, n, ngroup=100):
    """Resample 2d numpy array d via fourier-reshaping along
	last axis."""
    nold = d.shape[1]
    if n == nold: return d
    res = np.zeros([d.shape[0], n], dtype=d.dtype)
    dn = n - nold
    for di in range(0, d.shape[0], ngroup):
        fd = fft.fft(d[di:di + ngroup])
        if n < nold:
            fd = np.concatenate([fd[:, :n / 2], fd[:, n / 2 - dn:]], 1)
        else:
            fd = np.concatenate([
                fd[:, :nold / 2],
                np.zeros([len(fd), n - nold], fd.dtype), fd[:, nold / 2:]
            ], -1)
        res[di:di + ngroup] = fft.ifft(fd, normalize=True).real
    del fd
    res *= float(n) / nold
    return res
Esempio n. 21
0
	def __init__(self, data, beam, dr, prior="uniform", verbose=False):
		self.data = data
		# Beam setup
		self.beam = beam
		self.beam_pre = utils.interpol_prefilter(beam)
		self.dr   = dr
		self.pos = self.data.rhs.posmap()
		self.box = np.sort(self.data.rhs.box(),1)
		# Noise setup
		self.hdiv  = data.div**0.5
		self.ihdiv = self.hdiv.copy()
		self.ihdiv[self.ihdiv>0] **= -1
		# Build fourier-version of correlation
		self.fcorr  = fft.fft(self.data.corr, axes=(-2,-1))
		if np.any(self.fcorr==0): raise ValueError("Invalid noise correlations")
		self.verbose = verbose
		# Prior
		self.prior = prior
		self.i = 0
		self.post0 = None
		self.min_profile = 0.2
Esempio n. 22
0
	def __init__(self, data, beam, dr, prior="uniform", verbose=False):
		self.data = data
		# Beam setup
		self.beam = beam
		self.beam_pre = utils.interpol_prefilter(beam)
		self.dr   = dr
		self.pos = self.data.rhs.posmap()
		self.box = np.sort(self.data.rhs.box(),1)
		# Noise setup
		self.hdiv  = data.div**0.5
		self.ihdiv = self.hdiv.copy()
		self.ihdiv[self.ihdiv>0] **= -1
		# Build fourier-version of correlation
		self.fcorr  = fft.fft(self.data.corr, axes=(-2,-1))
		if np.any(self.fcorr==0): raise ValueError("Invalid noise correlations")
		self.verbose = verbose
		# Prior
		self.prior = prior
		self.i = 0
		self.post0 = None
		self.min_profile = 0.2
Esempio n. 23
0
def convolve(map, fmap):
	return fft.ifft(fft.fft(map, axes=(-2,-1))*fmap,axes=(-2,-1), normalize=True).real
Esempio n. 24
0
 def __init__(self, shape, corrfun, ndet):
     ps = fft.fft(corrfun + 0j, axes=[-2, -1]).real
     ps *= (ndet - 1) / np.max(ps)
     self.weight = 1 / (1 + ps)
Esempio n. 25
0

for i in range(Nstack):

    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
Esempio n. 26
0
        #                  uEqualsL=not(cluster))

        qest = EstimatorSmooth(shape_dat,
                               wcs_dat,
                               theory,
                               theory,
                               noiseX2dTEB=[nT, nP, nP],
                               noiseY2dTEB=[nT, nP, nP],
                               kBeamX=kbeam_dat,
                               kBeamY=kbeam_dat,
                               doCurl=False,
                               TOnly=not (pol),
                               gradCut=grad_cut,
                               uEqualsL=not (cluster))

    fkmaps = fftfast.fft(measured, axes=[-2, -1])

    if pol:
        qest.updateTEB_X(fkmaps[0], fkmaps[1], fkmaps[2], alreadyFTed=True)
    else:
        qest.updateTEB_X(fkmaps, alreadyFTed=True)

    qest.updateTEB_Y()

    for polcomb in pol_list:
        print(("Reconstructing", polcomb, " for ", i, " ..."))
        kappa_recon = enmap.samewcs(qest.getKappa(polcomb).real, measured)
        if i == 0:
            io.quickPlot2d(kappa_recon, out_dir + "kappa_recon_single.png")
        kappa_recon -= kappa_recon.mean()
        if cluster:
Esempio n. 27
0
        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")

    fkmaps = fftfast.fft(measured, axes=[-2, -1])
    if deconvolve_beam: fkmaps = np.nan_to_num(fkmaps / kbeam_dat)

    if maxlike and cluster:
        polcomb = "TT"
        fkmapsdc = np.nan_to_num(fkmaps / kbeam_dat)
        maps = enmap.samewcs(
            fftfast.ifft(fkmapsdc * fMaskCMB_T, normalize=True,
                         axes=[-2, -1]).real, measured)
        #kappa_model = init_kappa_model
        k = 0
        io.quickPlot2d(maps, out_dir + "map_iter_" + str(k).zfill(3) + ".png")

        from scipy.integrate import simps
        Ny, Nx = shape_dat[-2:]
        pixScaleY, pixScaleX = enmap.pixshape(shape_dat, wcs_dat)
Esempio n. 28
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)
Esempio n. 29
0
    # olensed = enmap.ndmap(lensed.copy() if abs(pixratio-1.)<1.e-3 else resample.resample_fft(lensed.copy(),shape_dat),wcs_dat)
    # flensed = fftfast.fft(lensed,axes=[-2,-1])
    # flensed *= parray_sim.lbeam
    # lensed = fftfast.ifft(flensed,axes=[-2,-1],normalize=True).real
    # if rank==0: print "Adding noise..."
    # noise = parray_sim.get_noise_sim(seed=index+20000)
    # lensed += noise
    # if rank==0: print "Downsampling..."
    # cmb = lensed if abs(pixratio-1.)<1.e-3 else resample.resample_fft(lensed,shape_dat)

    # === ADD NOISE AFTER DOWNSAMPLE
    if rank == 0: print "Beam convolving..."
    olensed = enmap.ndmap(
        lensed.copy() if abs(pixratio - 1.) < 1.e-3 else resample.resample_fft(
            lensed.copy(), shape_dat), wcs_dat)
    flensed = fftfast.fft(olensed, axes=[-2, -1])
    flensed *= parray_dat.lbeam
    lensed = fftfast.ifft(flensed, axes=[-2, -1], normalize=True).real
    if rank == 0: print "Adding noise..."
    noise = parray_dat.get_noise_sim(seed=index + 20000)

    lcents, noise1d = lbinner_dat.bin(fmaps.get_simple_power_enmap(noise))
    mpibox.add_to_stats('noisett', noise1d)

    lensed += noise
    if rank == 0: print "Downsampling..."
    cmb = lensed

    cmb = enmap.ndmap(cmb, wcs_dat)
    if rank == 0: print "Calculating powers for diagnostics..."
    utt2d = fmaps.get_simple_power_enmap(
Esempio n. 30
0
from __future__ import print_function
import numpy as np
from sympy import Symbol, Function
import sympy
from enlib import fft as efft, enmap, bench
from orphics import maps, io, stats, cosmology, lensing
import os, sys
"""
Routines to reduce and evaluate symbolic mode coupling integrals
"""

ifft = lambda x: efft.ifft(x, axes=[-2, -1], normalize=True)
fft = lambda x: efft.fft(x, axes=[-2, -1])


def factorize_2d_convolution_integral(expr,
                                      l1funcs=None,
                                      l2funcs=None,
                                      groups=None,
                                      validate=True):
    """Reduce a sympy expression of variables l1x,l1y,l2x,l2y,l1,l2 into a sum of 
    products of factors that depend only on vec(l1) and vec(l2) and neither, each. If the expression
    appeared as the integrand in an integral over vec(l1), where 
    vec(l2) = vec(L) - vec(l1) then this reduction allows one to evaluate the 
    integral as a function of vec(L) using FFTs instead of as a convolution.
    """

    # Generic message if validation fails
    val_fail_message = "Validation failed. This expression is likely not reducible to FFT form."
    # Get the 2D convolution cartesian variables
    l1x, l1y, l2x, l2y, l1, l2 = get_ells()
Esempio n. 31
0
    
    s,logdet = np.linalg.slogdet(cov)
    print((k,M,s,logdet,np.linalg.cond(cov)))
    assert s>0
        
    Ms.append(  M )
    logdets.append( logdet )
    cinvs.append( pinv2(cov) )

mrange = np.array(Ms)
    
for i in range(N):
    lnlikes = []
    cmb_map = pa.get_unlensed_cmb(seed=2*i+100000000)
    lensed = lensing.lens_map_flat_pix(cmb_map, alpha_pix,order=lens_order) if np.abs(M)>1.e-3 else cmb_map
    flensed = fftfast.fft(lensed,axes=[-2,-1])
    flensed *= pa.lbeam
    lensed = fftfast.ifft(flensed,axes=[-2,-1],normalize=True).real
    noise = pa.get_noise_sim(seed=2*i+1+100000000)
    measured = lensed + noise

    for k,M in enumerate(mrange):
    
        logdet = logdets[k]
        cinv = cinvs[k]
        
        lnlikeval = lnlike(logdet,cinv,measured)


        lnlikes.append(lnlikeval)
Esempio n. 32
0
                                       rhs, U)
        corrfun = calc_cmode_corrfun(U.ushape, U.uwcs, offset_upos,
                                     corrfun_smoothing)
        W = WeightMat(U.ushape, corrfun, 4)  #ndet)
    else:
        W = None

    # The H in our equation is related to the hitcount, but isn't exactly it.
    # normalize_hits approximates it using the hitcounts.
    H = normalize_hits(hits)

    # Apply weight to rhs
    if W is not None:
        iH = 1 / np.maximum(H, np.max(H) * 1e-2)
        urhs = U.apply(rhs * iH)
        ft = fft.fft(urhs + 0j, axes=[-2, -1])
        ft = W.apply(ft)
        urhs = fft.ifft(ft, urhs + 0j, axes=[-2, -1], normalize=True).real
        rhs = U.trans(urhs, rhs) * H

    if rhs_tot is None: rhs_tot = rhs
    else: rhs_tot += rhs

    infos.append(
        bunch.Bunch(U=U,
                    N=N,
                    H=H,
                    W=W,
                    pattern=pattern,
                    site=site,
                    srate=srate,
Esempio n. 33
0
def TQUtoPureTEB(T_map,Q_map,U_map,modLMap,angLMap,windowDict,method='pure'):

    window = windowDict

    win =window['Win']
    dWin_dx=window['dWin_dx']
    dWin_dy=window['dWin_dy']
    d2Win_dx2=window['d2Win_dx2'] 
    d2Win_dy2=window['d2Win_dy2']
    d2Win_dxdy=window['d2Win_dxdy']

    T_temp=T_map.copy()*win
    fT=fft(T_temp,axes=[-2,-1])
    
    Q_temp=Q_map.copy()*win
    fQ=fft(Q_temp,axes=[-2,-1])
    
    U_temp=U_map.copy()*win
    fU=fft(U_temp,axes=[-2,-1])
    
    fE=fT.copy()
    fB=fT.copy()
    
    fE=fQ[:]*np.cos(2.*angLMap)+fU[:]*np.sin(2.*angLMap)
    fB=-fQ[:]*np.sin(2.*angLMap)+fU[:]*np.cos(2.*angLMap)
    
    if method=='standard':
        return fT, fE, fB
    
    Q_temp=Q_map.copy()*dWin_dx
    QWx=fft(Q_temp,axes=[-2,-1])
    
    Q_temp=Q_map.copy()*dWin_dy
    QWy=fft(Q_temp,axes=[-2,-1])
    
    U_temp=U_map.copy()*dWin_dx
    UWx=fft(U_temp,axes=[-2,-1])
    
    U_temp=U_map.copy()*dWin_dy
    UWy=fft(U_temp,axes=[-2,-1])
    
    U_temp=2.*Q_map*d2Win_dxdy-U_map*(d2Win_dx2-d2Win_dy2)
    QU_B=fft(U_temp,axes=[-2,-1])
 
    U_temp=-Q_map*(d2Win_dx2-d2Win_dy2)-2.*U_map*d2Win_dxdy
    QU_E=fft(U_temp,axes=[-2,-1])
    
    modLMap=modLMap+2


    fB[:] += QU_B[:]*(1./modLMap)**2
    fB[:]-= (2.*1j)/modLMap*(np.sin(angLMap)*(QWx[:]+UWy[:])+np.cos(angLMap)*(QWy[:]-UWx[:]))
    
    if method=='hybrid':
        return fT, fE, fB
    
    fE[:]+= QU_E[:]*(1./modLMap)**2
    fE[:]-= (2.*1j)/modLMap*(np.sin(angLMap)*(QWy[:]-UWx[:])-np.cos(angLMap)*(QWx[:]+UWy[:]))
    
    if method=='pure':
        return fT, fE, fB
Esempio n. 34
0
	# Set up the weight matrix W
	if args.cmode > 0:
		offset_upos = calc_offset_upos(pattern, offset_array, offset_det, site, rhs, U)
		corrfun     = calc_cmode_corrfun(U.ushape, U.uwcs, offset_upos, corrfun_smoothing)
		W  = WeightMat(U.ushape, corrfun, 4)#ndet)
	else: W = None

	# The H in our equation is related to the hitcount, but isn't exactly it.
	# normalize_hits approximates it using the hitcounts.
	H = normalize_hits(hits)

	# Apply weight to rhs
	if W is not None:
		iH  = 1/np.maximum(H,np.max(H)*1e-2)
		urhs= U.apply(rhs*iH)
		ft  = fft.fft(urhs+0j, axes=[-2,-1])
		ft  = W.apply(ft)
		urhs= fft.ifft(ft, urhs+0j, axes=[-2,-1], normalize=True).real
		rhs = U.trans(urhs, rhs)*H
	
	if rhs_tot is None: rhs_tot = rhs
	else: rhs_tot += rhs

	infos.append(bunch.Bunch(U=U,N=N,H=H,W=W,pattern=pattern,site=site,srate=srate,scale=scale,speed=speed))

rhs = utils.allreduce(rhs_tot, comm)

#info = infos[0]
#foo  = rhs*info.H
#enmap.write_map("test1.fits", foo)
#bar  = enmap.samewcs(info.U.apply(foo),foo)
Esempio n. 35
0
	def __init__(self, shape, corrfun, ndet):
		ps  = fft.fft(corrfun+0j,axes=[-2,-1]).real
		ps *= (ndet-1)/np.max(ps)
		self.weight = 1/(1+ps)
Esempio n. 36
0
                         fmaskY2dTEB=[fMaskCMB] * 3,
                         fmaskKappa=fMask,
                         doCurl=False,
                         TOnly=True,
                         halo=True,
                         gradCut=gradCut,
                         verbose=False,
                         loadPickledNormAndFilters=None,
                         savePickledNormAndFilters=None)

    lensedMapX = stamp.copy() * win
    lensedMapY = stamp.copy() * win

    try:
        fotX = np.nan_to_num(
            fft(lensedMapX, axes=[-2, -1]) / beamTemplate[:, :])
    except:
        print(("skipping ", i, ra, dec))
        i -= 1
        continue
    fotY = np.nan_to_num(fft(lensedMapY, axes=[-2, -1]) / beamTemplate[:, :])

    if i % 10 == 0: print(("Reconstructing", i, " ..."))
    qest.updateTEB_X(fotX, alreadyFTed=True)
    qest.updateTEB_Y(fotY, alreadyFTed=True)
    kappa = qest.getKappa(polCombList[0]).real / w2

    kappaStack += kappa

N = i
kappaStack /= N
Esempio n. 37
0
def kfilter_map(imap, kfilter):
    return np.real(
        ifft(fft(imap, axes=[-2, -1]) * kfilter, axes=[-2, -1],
             normalize=True))