def get_synth_maps(): ulm_t1 = np.sqrt((np.random.rand(len(ellArr)) - 0.5 + 1j*(np.random.rand(len(ellArr)) - 0.5)) * (lmax**2 - (ellArr-50)**2)) vlm_t1 = np.sqrt((np.random.rand(len(ellArr)) - 0.5 + 1j*(np.random.rand(len(ellArr)) - 0.5)) * (lmax**2*1.5 - (ellArr-50)**2)) wlm_t1 = np.sqrt((np.random.rand(len(ellArr)) - 0.5 + 1j*(np.random.rand(len(ellArr)) - 0.5)) * (lmax**2*1.7 - (ellArr-50)**2)) r_t1 = hp.alm2map(ulm_t1, NSIDE) ulm_t1_imag = hp.map2alm(r_t1.imag) ulm_t2 = ulm_t1 - 1j*ulm_t1_imag r1map = hp.alm2map(ulm_t2, NSIDE) r_map = hp.alm2map(hp.map2alm(r1map), NSIDE) hlmp_t1 = (vlm_t1 + 1j*wlm_t1)/np.sqrt(2) hlmm_t1 = (vlm_t1 - 1j*wlm_t1)/np.sqrt(2) t1map, p1map = hp.alm2map_spin((hlmp_t1, hlmm_t1), NSIDE, 1, lmax) hlmp_t1_imag, hlmm_t1_imag = hp.map2alm_spin((t1map.imag, p1map.imag), 1) hlmp = hlmp_t1 - 1j*hlmp_t1_imag hlmm = hlmm_t1 - 1j*hlmm_t1_imag t1map, p1map = hp.alm2map_spin((hlmm, hlmp), NSIDE, 1, lmax) h1map, h2map = hp.alm2map_spin(hp.map2alm_spin((t1map, p1map), 1), NSIDE, 1, lmax) return r_map, h1map, h2map
def _get_wEBlm(window_scal, lmax=None, maps=False): ''' Calculate the E/B-type alms from the vector and tensor windows. Constructs the vector and tensor windows from the scalar wlms and then masks the resulting maps. This masking results in non-zero B-mode type wlms. ''' mask = np.ones_like(window_scal) mask[window_scal == 0] = 0 window_vect, window_tens = H_ext.window2vecttens(window_scal, mask=mask, lmax=lmax) wlm = H.map2alm(window_scal, lmax=lmax) n = len(wlm) wEBlm = np.empty([5, n], dtype=np.complex) wEBlm[0, :] = -wlm wlm_tmp = H.map2alm_spin(window_vect, 1, lmax=lmax) wEBlm[1, :] = wlm_tmp[0] wEBlm[-1, :] = wlm_tmp[1] wlm_tmp = H.map2alm_spin(window_tens, 2, lmax=lmax) wEBlm[2, :] = wlm_tmp[0] wEBlm[-2, :] = wlm_tmp[1] if maps: window_vect = window_vect[0] + 1j*window_vect[1] window_tens = window_tens[0] + 1j*window_tens[1] return wEBlm, (window_vect, window_tens) else: return wEBlm
def get_ElmBlm(filename='test_elmblm.npy', Qmap=None, Umap=None, mask=None, lmax=100, add_beam=None, div_beam=None, healpy_format=False, recalc=False, filtermap=False, l0=None, save=False): """computes and saves 2d (Elms, Blms) from given Q and U maps, corrected for sqrt(fsky) """ if not recalc and os.path.exists(data_path + filename): Elm2d, Blm2d = np.load(data_path + filename) return Elm2d, Blm2d fsky = mask.sum() / len(mask) Elm, Blm = hp.map2alm_spin((Qmap * mask, Umap * mask), 2, lmax=lmax) Elm /= np.sqrt(fsky) Blm /= np.sqrt(fsky) if add_beam is not None: hp.sphtfunc.almxfl(Elm, add_beam, inplace=True) hp.sphtfunc.almxfl(Blm, add_beam, inplace=True) if div_beam is not None: hp.sphtfunc.almxfl(Elm, 1. / div_beam, inplace=True) hp.sphtfunc.almxfl(Blm, 1. / div_beam, inplace=True) if not healpy_format: ls, ms = hp.sphtfunc.Alm.getlm(lmax, np.arange(len(Elm))) Elm = make2d_alm_square(Elm, lmax, ls, ms) Blm = make2d_alm_square(Blm, lmax, ls, ms) if save: np.save(data_path + filename, [Elm, Blm]) return Elm, Blm
def test_map2alm_spin_spin_precomputed(self): """ compare map2alm_spin outputs to some precomputed results for spin=1,2,3 """ for spin in [1,2,3]: tglm, tclm = hp.map2alm_spin( [maps[spin].real, maps[spin].imag], spin, lmax_precomputed ) np.testing.assert_array_almost_equal( glms[spin], tglm, decimal=7) np.testing.assert_array_almost_equal( clms[spin], tclm, decimal=7)
def get_spin1_alms(map_r, map_trans): """Get the vector spherical harmonic coefficients for spin1 harmonics. Parameters: ----------- map_r - np.ndarray(ndim=1, dtype=float) map containing radial component of vector field map_trans - list len(map_trans) = 2 map_trans[0] - map of vector field corresponding to +1 component map_trans[1] - map of vector field corresponding to -1 component Returns: -------- alm2r - spin0 spherical harmonic coefficients alm2v - spin1 spherical harmonic coefficients for s=+1 alm2w - spin1 spherical harmonic coefficients for s=-1 """ assert len(map_r) == len(map_trans[0]) == len(map_trans[1]) alm_r = hp.map2alm(map_r) alm_pm = hp.map2alm_spin(map_trans, 1) alm_v = -alm_pm[0] alm_w = -1j * alm_pm[1] return alm_r, alm_v, alm_w
def map2alm_spin(self,imap,lmax,spin_alm,spin_transform): dmap = -irot2d(np.stack((imap,imap.conj())),spin=spin_alm).real if self.hpix: res = hp.map2alm_spin(dmap,lmax=lmax,spin=spin_transform) return res else: return cs.map2alm(enmap.enmap(dmap,imap.wcs),spin=spin_transform,lmax=lmax)
def apply_ivf(self, det, tmap, pmap): assert(self.lmax == 1000) mask_t = qcinv.util.load_map(self.mask_t) mask_p = qcinv.util.load_map(self.mask_p) bl = dmc.get_bl(self.sim_lib.year, det)[0:self.lmax+1] pxw = hp.pixwin( self.sim_lib.nside )[0:self.lmax+1] # qcinv filtering for temperature dcf = self.lib_dir + "/dense_cache_det_" + det + ".pk" # id preconditioners lmax nside im em tr cache chain_descr = [ [ 2, ["split(dense("+dcf+"), 64, diag_cl)"], 256, 128, 3, 0.0, qcinv.cd_solve.tr_cg, qcinv.cd_solve.cache_mem()], [ 1, ["split(stage(2), 256, diag_cl)"], 512, 256, 3, 0.0, qcinv.cd_solve.tr_cg, qcinv.cd_solve.cache_mem()], [ 0, ["split(stage(1), 512, diag_cl)"], 1000, 512, np.inf, 1.0e-6, qcinv.cd_solve.tr_cg, qcinv.cd_solve.cache_mem()] ] ninv = ( hp.read_map( dmc.get_fname_iqumap(self.sim_lib.year, det, self.sim_lib.forered), hdu=1, field=3 ) / dmc.sigma0[(self.sim_lib.year, self.sim_lib.forered, 'T')][det]**2 / 1e6 * mask_t ) n_inv_filt = qcinv.opfilt_tt.alm_filter_ninv( ninv, bl*pxw, marge_monopole=True, marge_dipole=True, marge_maps=[] ) chain = qcinv.multigrid.multigrid_chain( qcinv.opfilt_tt, chain_descr, self.cl, n_inv_filt ) tlm = np.zeros( qcinv.util_alm.lmax2nlm(self.lmax), dtype=np.complex ) chain.solve( tlm, tmap ) # simple filtering for polarization. elm, blm = hp.map2alm_spin( (pmap.real * mask_p, pmap.imag * mask_p), 2, lmax=self.lmax ) ftl, fel, fbl = self.get_ftebl(det) hp.almxfl( elm, fel / bl / pxw, inplace=True ) hp.almxfl( blm, fbl / bl / pxw, inplace=True ) return tlm, elm, blm
def calc_alm(Imap, Qmap, Umap, mask=None, lmax=200, add_beam=None,div_beam=None, add_beamP=None,div_beamP=None, healpy_format=False): """computes alms, given maps and a mask, corrected for sqrt(fsky), optionally corrected for beams """ fsky = mask.sum() / len(mask) Tlm = hp.map2alm(Imap * mask, lmax=lmax) / np.sqrt(fsky) Elm, Blm = hp.map2alm_spin( (Qmap*mask,Umap*mask), 2, lmax=lmax ) Elm /= np.sqrt(fsky) Blm /= np.sqrt(fsky) if (add_beam is not None) and (add_beamP is not None): hp.sphtfunc.almxfl(Tlm, add_beam, inplace=True) hp.sphtfunc.almxfl(Elm, add_beam, inplace=True) hp.sphtfunc.almxfl(Blm, add_beam, inplace=True) if (div_beam is not None) and (div_beamP is not None): hp.sphtfunc.almxfl(Tlm, 1./div_beam, inplace=True) hp.sphtfunc.almxfl(Elm, 1./div_beam, inplace=True) hp.sphtfunc.almxfl(Blm, 1./div_beam, inplace=True) if not healpy_format: ls, ms = hp.sphtfunc.Alm.getlm(lmax, np.arange(len(Tlm))) Tlm = make2d_alm_square(Tlm, lmax, ls, ms) Elm = make2d_alm_square(Elm, lmax, ls, ms) Blm = make2d_alm_square(Blm, lmax, ls, ms) return Tlm,Elm,Blm
def get_ElmBlm(filename='test_elmblm.npy', Qmap=None, Umap=None, mask=None, lmax=100,add_beam=None,div_beam=None, healpy_format=False, recalc=False, filtermap=False, l0=None, save=False): """computes and saves 2d (Elms, Blms) from given Q and U maps, corrected for sqrt(fsky) """ if not recalc and os.path.exists(data_path + filename): Elm2d, Blm2d = np.load(data_path + filename) return Elm2d, Blm2d fsky = mask.sum() / len(mask) Elm, Blm = hp.map2alm_spin( (Qmap*mask,Umap*mask), 2, lmax=lmax ) Elm /= np.sqrt(fsky) Blm /= np.sqrt(fsky) if add_beam is not None: hp.sphtfunc.almxfl(Elm, add_beam, inplace=True) hp.sphtfunc.almxfl(Blm, add_beam, inplace=True) if div_beam is not None: hp.sphtfunc.almxfl(Elm, 1./div_beam, inplace=True) hp.sphtfunc.almxfl(Blm, 1./div_beam, inplace=True) if not healpy_format: ls, ms = hp.sphtfunc.Alm.getlm(lmax, np.arange(len(Elm))) Elm = make2d_alm_square(Elm, lmax, ls, ms) Blm = make2d_alm_square(Blm, lmax, ls, ms) if save: np.save(data_path + filename, [Elm,Blm]) return Elm, Blm
def _cache_eblm(self, idx): elm = self.unlcmbs.get_sim_elm(idx) blm = None if 'b' not in self.fields else self.unlcmbs.get_sim_blm(idx) dlm = self.get_sim_plm(idx) assert 'o' not in self.fields, 'not implemented' lmaxd = hp.Alm.getlmax(dlm.size) hp.almxfl(dlm, np.sqrt( np.arange(lmaxd + 1, dtype=float) * np.arange(1, lmaxd + 2)), inplace=True) Qlen, Ulen = self.lens_module.alm2lenmap_spin([elm, blm], [dlm, None], self.nside_lens, 2, nband=self.nbands, facres=self.facres, verbose=self.verbose) elm, blm = hp.map2alm_spin([Qlen, Ulen], 2, lmax=self.lmax) del Qlen, Ulen hp.write_alm(os.path.join(self.lib_dir, 'sim_%04d_elm.fits' % idx), elm) del elm hp.write_alm(os.path.join(self.lib_dir, 'sim_%04d_blm.fits' % idx), blm)
def calc_IP2_equil(Imap, Qmap, Umap, lmax=100): Tlm = hp.map2alm(Imap) Elm, Blm = hp.map2alm_spin((Qmap, Umap), 2) TEE = hp.alm2cl(Tlm, Elm**2) TBB = hp.alm2cl(Tlm, Blm**2) TEB = hp.alm2cl(Tlm, Elm * Blm) ls = np.arange(len(TEE)) return ls, TEE, TBB, TEB
def test_forward_backward_spin(self): """ compare map2alm_spin outputs to alm2map_spin inputs. tolerances are very loose. """ for spin in [1,2,3]: tcl = np.ones(self.lmax+1); tcl[0:spin] = 0. almg = hp.almxfl(self.almg, tcl, inplace=False) almc = hp.almxfl(self.almc, tcl, inplace=False) rmap, imap = hp.alm2map_spin( [almg, almc], self.nside, spin, self.lmax ) tglm, tclm = hp.map2alm_spin( [rmap, imap], spin, self.lmax ) np.testing.assert_allclose( almg, tglm, rtol=1.e-2, atol=1.e-2) np.testing.assert_allclose( almc, tclm, rtol=1.e-2, atol=1.e-2)
def _apply_ivf_p(self, pmap, soltn=None): assert len(pmap[0]) == hp.nside2npix(self.nside) and len( pmap[0]) == len(pmap[1]) elm, blm = hp.map2alm_spin([m for m in pmap], 2, lmax=self.lmax_fl) elm = hp.almxfl( elm, self.get_fel() * utils.cli(self.transf[:len(self.fel)])) blm = hp.almxfl( blm, self.get_fbl() * utils.cli(self.transf[:len(self.fbl)])) return elm, blm
def calc_prep(maps, s_cls, n_inv_filt): qmap, umap = np.copy(maps[0]), np.copy(maps[1]) assert len(qmap) == len(umap) lmax = len(n_inv_filt.b_transf) - 1 npix = len(qmap) n_inv_filt.apply_map([qmap, umap]) elm, blm = map2alm_spin([qmap, umap], 2, lmax=lmax) hp.almxfl(elm, n_inv_filt.b_transf * npix / (4. * np.pi), inplace=True) hp.almxfl(blm, n_inv_filt.b_transf * npix / (4. * np.pi), inplace=True) return eblm([elm, blm])
def calc_IP2_equil(Imap, Qmap, Umap, lmax=100): Tlm = hp.map2alm( Imap ) Elm,Blm = hp.map2alm_spin( (Qmap,Umap), 2 ) TEE = hp.alm2cl( Tlm, Elm**2 ) TBB = hp.alm2cl( Tlm, Blm**2 ) TEB = hp.alm2cl( Tlm, Elm*Blm ) ls = np.arange( len(TEE) ) return ls, TEE, TBB, TEB
def b_cov_T353_E143_B143(cl_file=pf.PLANCK_DATA_PATH+'bf_base_cmbonly_plikHMv18_TT_lowTEB_lmax4000.minimum.theory_cl',lmax=100): Imap = hp.read_map(pf.PLANCK_DATA_PATH + 'HFI_SkyMap_353_2048_R2.02_full.fits') Tlm = hp.map2alm(Imap,lmax=lmax) cltt = hp.alm2cl(Tlm,lmax=lmax) mask = pf.get_planck_mask(psky=70) Qmap, Umap = hp.read_map(pf.PLANCK_DATA_PATH + 'HFI_SkyMap_143_2048_R2.02_full.fits',field=(1,2)) Elm, Blm = hp.map2alm_spin( (Qmap*mask,Umap*mask), 2, lmax=lmax ) clee = hp.alm2cl(Elm,lmax=lmax) clbb = hp.alm2cl(Blm,lmax=lmax) cov = calc_b_cov_TEB(cltt, clee, clbb) return cov
def apply_ivf(self, det, tmap, pmap): mask_t = qcinv.util.load_map(self.mask_t) mask_p = qcinv.util.load_map(self.mask_p) bl = self.bl pxw = hp.pixwin(self.nside)[0:self.lmax+1] tlm = hp.map2alm( tmap * mask_t, lmax=self.lmax, iter=0, regression=False ) elm, blm = hp.map2alm_spin( (pmap.real * mask_p, pmap.imag * mask_p), 2, lmax=self.lmax ) hp.almxfl( tlm, self.ftl / bl / pxw, inplace=True ) hp.almxfl( elm, self.fel / bl / pxw, inplace=True ) hp.almxfl( blm, self.fbl / bl / pxw, inplace=True ) return tlm, elm, blm
def b_cov_TEB(lmax=100,frequency=353): """this one is map-based""" Imap,Qmap, Umap = hp.read_map(pf.PLANCK_DATA_PATH + 'HFI_SkyMap_{}_2048_R2.02_full.fits'.format(frequency),field=(0,1,2)) mask = pf.get_planck_mask() Tlm = hp.map2alm(Imap*mask,lmax=lmax) cltt = hp.alm2cl(Tlm,lmax=lmax) Elm, Blm = hp.map2alm_spin( (Qmap*mask,Umap*mask), 2, lmax=lmax ) clee = hp.alm2cl(Elm,lmax=lmax) clbb = hp.alm2cl(Blm,lmax=lmax) #hs = get_hs(lmax=100) cov = calc_b_cov_TEB(cltt, clee, clbb)#/hs return cov
def apodizedqu2pureeb(polxscal, polxvect, polxtens, lmax=None, mmax=None): ''' Constructs the pure E/B alms from polarization maps apodized by the scalar, vector, and tensor window ''' alm = H.map2alm((-polxtens[0], -polxtens[1]), lmax=lmax, mmax=mmax, pol=False) if lmax is None: lmax = H.Alm.getlmax(len(alm[0])) ell, m_tmp = H.Alm.getlm(lmax) idx = (ell >= 2) apurelm = (np.zeros_like(alm[0]), np.zeros_like(alm[0])) spinfact = 1.0 / np.sqrt( (ell[idx] - 1.0) * ell[idx] * (ell[idx] + 1.0) * (ell[idx] + 2.0)) apurelm[0][idx] += spinfact * alm[0][idx] apurelm[1][idx] += spinfact * alm[1][idx] alm = H.map2alm_spin(polxvect, 1, lmax=lmax, mmax=mmax) spinfact = 2.0 / np.sqrt((ell[idx] - 1.0) * (ell[idx] + 2.0)) apurelm[0][idx] += spinfact * alm[0][idx] apurelm[1][idx] += spinfact * alm[1][idx] alm = H.map2alm_spin(polxscal, 2, lmax=lmax, mmax=mmax) spinfact = 1.0 apurelm[0][idx] += spinfact * alm[0][idx] apurelm[1][idx] += spinfact * alm[1][idx] return apurelm
def _get_sim_Tgclm(self, idx, k, swapped=False, xfilt1=None, xfilt2=None): """ T only lensing potentials estimators """ f2map1 = self.f2map1 if not swapped else self.f2map2 f2map2 = self.f2map2 if not swapped else self.f2map1 xftl1 = xfilt1 if not swapped else xfilt2 xftl2 = xfilt2 if not swapped else xfilt1 tmap = f2map1.get_irestmap(idx, xfilt=xftl1) # healpy map G, C = f2map2.get_gtmap(idx, k=k, xfilt=xftl2) # 2 healpy maps G *= tmap C *= tmap del tmap G, C = hp.map2alm_spin([G, C], 1, lmax=self.lmax_qlm['T']) fl = - np.sqrt(np.arange(self.lmax_qlm['T'] + 1, dtype=float) * np.arange(1, self.lmax_qlm['T'] + 2)) hp.almxfl(G, fl, inplace=True) hp.almxfl(C, fl, inplace=True) return G, C
def apply_ivf(self, det, tmap, pmap): mask_t = qcinv.util.load_map(self.mask_t) mask_p = qcinv.util.load_map(self.mask_p) tlm = hp.map2alm( tmap * mask_t, lmax=self.lmax, iter=0, regression=False ) elm, blm = hp.map2alm_spin( (pmap.real * mask_p, pmap.imag * mask_p), 2, lmax=self.lmax ) bl = dmc.get_bl(self.sim_lib.year, det)[0:self.lmax+1] pxw = hp.pixwin( self.sim_lib.nside )[0:self.lmax+1] ftl, fel, fbl = self.get_ftebl(det) hp.almxfl( tlm, ftl / bl / pxw, inplace=True ) hp.almxfl( elm, fel / bl / pxw, inplace=True ) hp.almxfl( blm, fbl / bl / pxw, inplace=True ) return tlm, elm, blm
def apply_alm(self, alm): """B^dagger N^{-1} B""" lmax = alm.lmax hp.almxfl(alm.elm, self.b_transf, inplace=True) hp.almxfl(alm.blm, self.b_transf, inplace=True) qmap, umap = alm2map_spin((alm.elm, alm.blm), self.nside, 2, lmax) self.apply_map([qmap, umap]) # applies N^{-1} npix = len(qmap) telm, tblm = map2alm_spin([qmap, umap], 2, lmax=lmax) alm.elm[:] = telm alm.blm[:] = tblm hp.almxfl(alm.elm, self.b_transf * (npix / (4. * np.pi)), inplace=True) hp.almxfl(alm.blm, self.b_transf * (npix / (4. * np.pi)), inplace=True)
def lens_eblm(elm, dlm, blm=None, nside=2048, lmaxout=None, verbose=True, nband=16, facres=0): # FIXME : suppress the stupid intermediate step lenmap = eblm2lensmap(nside, elm, dlm, blm=blm, verbose=verbose, nband=nband, facres=facres) return hp.map2alm_spin([lenmap.real, lenmap.imag], 2, lmax=(lmaxout or hp.Alm.getlmax(elm.size)))
def calc_prep(maps, s_cls, n_inv_filt): tmap, qmap, umap = np.copy(maps[0]), np.copy(maps[1]), np.copy(maps[2]) assert(len(tmap) == len(qmap)); assert(len(tmap) == len(umap)) npix = len(tmap) n_inv_filt.apply_map([tmap, qmap, umap]) lmax = len(n_inv_filt.b_transf) - 1 tlm = hp.map2alm(tmap, lmax=lmax, iter=0, regression=False) tlm *= npix / (4.*np.pi) elm, blm = hp.map2alm_spin( [qmap, umap], 2, lmax=lmax) elm *= npix / (4.*np.pi); blm *= npix / (4.*np.pi) hp.almxfl( tlm, n_inv_filt.b_transf, inplace=True ) hp.almxfl( elm, n_inv_filt.b_transf, inplace=True ) hp.almxfl( blm, n_inv_filt.b_transf, inplace=True ) return teblm([tlm, elm, blm])
def calc_prep(maps, s_cls, n_inv_filt): tmap, qmap, umap = np.copy(maps[0]), np.copy(maps[1]), np.copy(maps[2]) assert (len(tmap) == len(qmap)) assert (len(tmap) == len(umap)) npix = len(tmap) n_inv_filt.apply_map([tmap, qmap, umap]) lmax = len(n_inv_filt.b_transf) - 1 tlm = hp.map2alm(tmap, lmax=lmax, iter=0) tlm *= npix / (4. * np.pi) elm, blm = hp.map2alm_spin([qmap, umap], 2, lmax=lmax) elm *= npix / (4. * np.pi) blm *= npix / (4. * np.pi) hp.almxfl(tlm, n_inv_filt.b_transf, inplace=True) hp.almxfl(elm, n_inv_filt.b_transf, inplace=True) hp.almxfl(blm, n_inv_filt.b_transf, inplace=True) return teblm([tlm, elm, blm])
def _get_sim_Pgclm(self, idx, k, swapped=False, xfilt1=None, xfilt2=None): """ Pol. only lensing potentials estimators """ f2map1 = self.f2map1 if not swapped else self.f2map2 f2map2 = self.f2map2 if not swapped else self.f2map1 xftl1 = xfilt1 if not swapped else xfilt2 xftl2 = xfilt2 if not swapped else xfilt1 repmap, impmap = f2map1.get_irespmap(idx, xfilt=xftl1) # complex spin 2 healpy maps Gs, Cs = f2map2.get_gpmap(idx, 3, k=k, xfilt=xftl2) # 2 healpy maps GC = (repmap - 1j * impmap) * (Gs + 1j * Cs) # (-2 , +3) Gs, Cs = f2map2.get_gpmap(idx, 1, k=k, xfilt=xftl2) GC -= (repmap + 1j * impmap) * (Gs - 1j * Cs) # (+2 , -1) del repmap, impmap, Gs, Cs G, C = hp.map2alm_spin([GC.real, GC.imag], 1, lmax=self.lmax_qlm['P']) del GC fl = - np.sqrt(np.arange(self.lmax_qlm['P'] + 1, dtype=float) * np.arange(1, self.lmax_qlm['P'] + 2)) hp.almxfl(G, fl, inplace=True) hp.almxfl(C, fl, inplace=True) return G, C
def analworker(i): print "This is analysis worker starting for map", i + 1, "/", nmaps QU_maps = hp.read_map(fits[i], field=(1, 2)) #(Q,U) pixrecip = np.concatenate((np.ones(2), np.reciprocal( hp.pixwin(hp.get_nside(QU_maps[0]), pol=True)[1][2:smoothing_lmax]) )) #P pixwin #Not defined for l < 2 pm_alms = hp.map2alm_spin(QU_maps, spin, lmax=smoothing_lmax - 1) del QU_maps hp.almxfl(pm_alms[0], pixrecip, inplace=True) #Correcting for pixwin hp.almxfl(pm_alms[1], pixrecip, inplace=True) #Correcting for pixwin #Reorder to S2LET alms pm_alms[0] = ps.lm_hp2lm(pm_alms[0], smoothing_lmax) pm_alms[1] = ps.lm_hp2lm(pm_alms[1], smoothing_lmax) P_alms = -1. * pm_alms[0] - 1.j * pm_alms[1] #CHECK THIS IS CORRECT! del pm_alms wav_maps, scal_maps = ps.analysis_lm2wav_manualtiling( P_alms, smoothing_lmax, ndir, spin, scal_tiles, wav_tiles.T.ravel(), scal_bandlims, wav_bandlims) del P_alms np.save(scal_outfits[i], scal_maps) del scal_maps #Splitting up output wavelet maps offset = 0 for j in xrange(jmax + 1): for n in xrange(ndir): bandlim = wav_bandlims[j] nelem = bandlim * (2. * bandlim - 1.) wav_outfits = wav_outfits_root[i] + '_j' + str(j) + '_n' + str( n + 1) + '.npy' np.save(wav_outfits, wav_maps[offset:offset + nelem]) offset += nelem del wav_maps return 0
def apply_alm(self, alm): # applies Y^T N^{-1} Y lmax = alm.lmax hp.almxfl(alm.tlm, self.b_transf, inplace=True) hp.almxfl(alm.elm, self.b_transf, inplace=True) hp.almxfl(alm.blm, self.b_transf, inplace=True) tmap = hp.alm2map(alm.tlm, self.nside) qmap, umap = hp.alm2map_spin( (alm.elm, alm.blm), self.nside, 2 ) self.apply_map( [tmap, qmap, umap] ) alm.tlm[:] = hp.map2alm(tmap, lmax=lmax, iter=0, regression=False) alm.tlm[:] *= (self.npix / (4.*np.pi)) telm, tblm = hp.map2alm_spin( [qmap, umap], 2, lmax=lmax ) alm.elm[:] = telm; alm.blm[:] = tblm hp.almxfl(alm.tlm, self.b_transf, inplace=True) hp.almxfl(alm.elm, self.b_transf, inplace=True) hp.almxfl(alm.blm, self.b_transf, inplace=True)
def apply_alm(self, alm): # applies Y^T N^{-1} Y lmax = alm.lmax hp.almxfl(alm.tlm, self.b_transf, inplace=True) hp.almxfl(alm.elm, self.b_transf, inplace=True) hp.almxfl(alm.blm, self.b_transf, inplace=True) tmap = hp.alm2map(alm.tlm, self.nside) qmap, umap = hp.alm2map_spin((alm.elm, alm.blm), self.nside, 2) self.apply_map([tmap, qmap, umap]) alm.tlm[:] = hp.map2alm(tmap, lmax=lmax, iter=0) alm.tlm[:] *= (self.npix / (4. * np.pi)) telm, tblm = hp.map2alm_spin([qmap, umap], 2, lmax=lmax) alm.elm[:] = telm alm.blm[:] = tblm hp.almxfl(alm.tlm, self.b_transf, inplace=True) hp.almxfl(alm.elm, self.b_transf, inplace=True) hp.almxfl(alm.blm, self.b_transf, inplace=True)
def check_cl_sims(nmaps=1,lmax=1000,nside=2048, read_file=False, filename='testsky.fits',frequency=100, beam=None, beamP=None, smear=True, nonoise=False, cl_file='bf_base_cmbonly_plikHMv18_TT_lowTEB_lmax4000.minimum.theory_cl'): if read_file and os.path.exists(data_path + filename): Tmap, Qmap, Umap = hp.read_map(data_path + filename, field=(0,1,2)) else: if nonoise: Tmap, Qmap, Umap = simulate_cmb(nside=nside, lmax=lmax,save=False, smear=smear, beam=beam, beamP=beamP, cl_file=cl_file) else: Tmap, Qmap, Umap = observe_cmb_sky(save=False, nside=nside, npix=None, lmax=3000, frequency=frequency, beam=beam, beamP=beamP, cl_file=cl_file) Tlm = hp.map2alm(Tmap, lmax=lmax) Elm,Blm = hp.map2alm_spin( (Qmap,Umap), 2, lmax=lmax ) if smear: if (beam is None) or (beamP is None) : hdulist = fits.open(data_path + 'HFI_RIMO_Beams-100pc_R2.00.fits') beam = hdulist[beam_index['{}'.format(frequency)]].data.NOMINAL[0][:lmax+1] beamP = hdulist[beam_index['{}P'.format(frequency)]].data.NOMINAL[0][:lmax+1] hp.sphtfunc.almxfl(Tlm, 1./beam, inplace=True) hp.sphtfunc.almxfl(Elm, 1./beamP, inplace=True) hp.sphtfunc.almxfl(Blm, 1./beamP, inplace=True) ls = np.arange(lmax+1) factor = ls * ( ls + 1. ) / (2.*np.pi) cltt = hp.alm2cl(Tlm) * factor clee = hp.alm2cl(Elm) * factor clbb = hp.alm2cl(Blm) * factor clte = hp.alm2cl(Tlm, Elm) * factor cl = get_theory_cls() ls_theory = cl[0][:lmax+1] factor_theory = ls_theory * ( ls_theory + 1. ) / (2.*np.pi) cltt_theory = cl[1][:lmax+1] * factor_theory clte_theory = cl[2][:lmax+1] * factor_theory clee_theory = cl[3][:lmax+1] * factor_theory clbb_theory = cl[4][:lmax+1] * factor_theory plt.figure() plt.plot(ls, cltt, label='sims') plt.plot(ls_theory, cltt_theory,label='theory TT') plt.legend() plt.figure() plt.plot(ls, clte, label='sims') plt.plot(ls_theory, clte_theory,label='theory TE') plt.legend() plt.figure() plt.plot(ls, clee, label='sims') plt.plot(ls_theory, clee_theory,label='theory EE') plt.legend() plt.figure() plt.plot(ls, clbb, label='sims') plt.plot(ls_theory, clbb_theory,label='theory BB') plt.legend()
def get_alms( maps=None, mask=None, maplabel='353', showI=False, pol=True, intensity=True, rewrite=False, writemap=False, savealms=True, masktype='PowerSpectra', #'GalPlane2', lmax=100): """Each written map file must contain I,Q,U, and each alms file must contain Tlm, Elm, and Blm. """ newname = 'alms_lmax{}_mask_{}__'.format(lmax, masktype) + maplabel + '.npy' if not os.path.exists(data_path + newname) or rewrite: print 'alms file {} does not exist; calculating alms...'.format( newname) if mask is None: if masktype == 'PowerSpectra': maskname = 'HFI_PowerSpect_Mask_2048_R1.10.fits' maskfield = 0 elif masktype == 'GalPlane60': maskname = 'HFI_Mask_GalPlane-apo0_2048_R2.00.fits', maskfield = 2 elif masktype == 'no': maskname = 'HFI_PowerSpect_Mask_2048_R1.10.fits' maskfield = 0 mask = hp.read_map(data_path + maskname, field=maskfield) if masktype == 'no': mask = mask * 0. + 1. masknside = hp.get_nside(mask) if maps is None: Imap, Qmap, Umap = hp.read_map( data_path + 'HFI_SkyMap_{}_2048_R2.02_full.fits'.format(maplabel), hdu=1, field=(0, 1, 2)) mapnside = hp.get_nside(Imap) else: if intensity and pol: Imap = maps[0] Qmap = maps[1] Umap = maps[2] mapnside = hp.get_nside(Imap) elif intensity and not pol: Imap = maps[0] mapnside = hp.get_nside(Imap) elif pol and not intensity: Qmap = maps[0] Umap = maps[1] mapnside = hp.get_nside(Qmap) if masknside != mapnside: print 'adjusting mask to match map resolution...' mask = hp.pixelfunc.ud_grade(mask, nside_out=mapnside) if showI: hp.mollview(Imap * mask) alms = [] if intensity: Imap = Imap * mask Tlm = hp.map2alm(Imap, lmax=lmax) alms.append(Tlm) if pol: Qmap *= mask Umap *= mask Elm, Blm = hp.map2alm_spin((Qmap, Umap), 2, lmax=lmax) alms.append(Elm) alms.append(Blm) #this will only work if get_intensity and get_pol if writemap and intensity and pol: hp.fitsfunc.write_map(data_path + newname, [Imap, Qmap, Umap]) if savealms and intensity and pol: np.save(data_path + newname, alms) return alms else: alms = np.load(data_path + newname, 'r') if intensity and pol: return alms[0], alms[1], alms[2] else: if intensity: return alms[0] if pol: return alms[1], alms[2]
def calc_TEB(Imap_name='HFI_SkyMap_353_2048_R2.02_full.fits', Pmap_name='HFI_SkyMap_353_2048_R2.02_full.fits', nus=None, fwhm=0.063, nside=16, lmax=100, lmaps_only=False, filename=None): """Master function for computing the bispectrum TEB """ # read from file if it's there if filename is None: filename = 'bispectrum_lmax{}'.format(lmax) if nus is not None: filename += '_{}-{}-{}GHz.npy'.format(nus[0],nus[1],nus[1]) else: filename += '_{}'.format(Imap_name[-5]) if Imap_name != Pmap_name: filename += '_{}.npy'.format(Pmap_name[-5]) else: filename += '.npy' print 'looking for {} ...'.format(filename) if os.path.exists(filename) and not lmaps_only: bispectrum = np.load(filename, 'r') return bispectrum # compute it, if the file doesn't exist if nus is not None: Imap_name = 'HFI_SkyMap_{}_2048_R2.02_full.fits'.format(nus[0]) Pmap_name = 'HFI_SkyMap_{}_2048_R2.02_full.fits'.format(nus[1]) title = '$I_{%i} P^2_{%i}$ (equilateral)' % (nus[0],nus[1]) Imap = prepare_map( Imap_name, field=0, nside_out=nside, fwhm=fwhm ) Tlm = hp.map2alm( Imap, lmax=lmax ) Qmap, Umap = prepare_map( Pmap_name, field=(1,2), nside_out=nside, fwhm=fwhm ) Elm,Blm = hp.map2alm_spin( (Qmap,Umap), 2, lmax=lmax ) if lmax is None: lmax = hp.sphtfunc.Alm.getlmax(len(Tlm)) ls, ms = hp.sphtfunc.Alm.getlm(lmax,np.arange(len(Tlm))) lmin = ls.min() mapsize = len(Imap) pixelsize = hp.pixelfunc.nside2pixarea(nside) Ylm = calc_Ylm(Imap, ls, ms) #return Ylm, Tlm, ls, ms print 'calculating Tl,El,Bl ...' Tl = sum_over_m(Tlm, Ylm, ls, lmax=lmax, lmin=lmin, mapsize=mapsize) El = sum_over_m(Elm, Ylm, ls, lmax=lmax, lmin=lmin, mapsize=mapsize) Bl = sum_over_m(Blm, Ylm, ls, lmax=lmax, lmin=lmin, mapsize=mapsize) if lmaps_only: return Tl,El,Bl hs = get_hs(lmin=lmin, lmax=lmax) print 'calculating bispectrum ...' bispectrum = calc_bispectrum(Tl, El, Bl, hs, pixelsize, lmax=lmax, lmin=lmin, mapsize=mapsize) clean_bispectrum_of_naninf(bispectrum, hs, inplace=True) np.save(filename, bispectrum) return bispectrum
def get_alms(maps=None, mask=None, maplabel='353', showI=False, pol=True, intensity=True, rewrite=False, writemap=False, savealms=True, masktype='PowerSpectra',#'GalPlane2', lmax=100): """Each written map file must contain I,Q,U, and each alms file must contain Tlm, Elm, and Blm. """ newname = 'alms_lmax{}_mask_{}__'.format(lmax, masktype) + maplabel + '.npy' if not os.path.exists(data_path + newname) or rewrite: print 'alms file {} does not exist; calculating alms...'.format(newname) if mask is None: if masktype == 'PowerSpectra': maskname = 'HFI_PowerSpect_Mask_2048_R1.10.fits' maskfield = 0 elif masktype == 'GalPlane60': maskname = 'HFI_Mask_GalPlane-apo0_2048_R2.00.fits', maskfield = 2 elif masktype == 'no': maskname = 'HFI_PowerSpect_Mask_2048_R1.10.fits' maskfield = 0 mask = hp.read_map(data_path + maskname, field=maskfield) if masktype == 'no': mask = mask*0. + 1. masknside = hp.get_nside(mask) if maps is None: Imap,Qmap,Umap = hp.read_map( data_path + 'HFI_SkyMap_{}_2048_R2.02_full.fits'.format(maplabel),hdu=1, field=(0,1,2) ) mapnside = hp.get_nside(Imap) else: if intensity and pol: Imap = maps[0] Qmap = maps[1] Umap = maps[2] mapnside = hp.get_nside(Imap) elif intensity and not pol: Imap = maps[0] mapnside = hp.get_nside(Imap) elif pol and not intensity: Qmap = maps[0] Umap = maps[1] mapnside = hp.get_nside(Qmap) if masknside != mapnside: print 'adjusting mask to match map resolution...' mask = hp.pixelfunc.ud_grade(mask, nside_out=mapnside) if showI: hp.mollview(Imap*mask) alms = [] if intensity: Imap = Imap*mask Tlm = hp.map2alm(Imap, lmax=lmax) alms.append(Tlm) if pol: Qmap *= mask Umap *= mask Elm,Blm = hp.map2alm_spin( (Qmap,Umap), 2, lmax=lmax ) alms.append(Elm) alms.append(Blm) #this will only work if get_intensity and get_pol if writemap and intensity and pol: hp.fitsfunc.write_map( data_path + newname, [Imap, Qmap, Umap]) if savealms and intensity and pol: np.save(data_path + newname, alms) return alms else: alms = np.load(data_path + newname, 'r') if intensity and pol: return alms[0], alms[1], alms[2] else: if intensity: return alms[0] if pol: return alms[1], alms[2]
lat_HG = np.linspace(-59.8 + 90, 59.8 + 90, 300) * np.pi / 180 lon_HG = np.linspace(0.2, 359.8, 900) * np.pi / 180 dtheta_obs, dphi_obs = lat_HG[1] - lat_HG[0], lon_HG[1] - lon_HG[0] LON, LAT = np.meshgrid(lon_HG, lat_HG) print(f"[{args.year}] [{args.daynum}] Making healPy maps") vlat_map, vlat_mask, th_map, ph_map = make_map(LAT[mask], LON[mask], vlat[mask], NSIDE) vlon_map, vlon_mask, th_map, ph_map = make_map(LAT[mask], LON[mask], vlon[mask], NSIDE) map2trans = get_spin1_maps((vlat_map, vlon_map), vlat_mask) print(f"[{args.year}] [{args.daynum}] SHT of healPy maps") alm_pm = hp.map2alm_spin(map2trans, 1) alm_v = -alm_pm[0] * sqrt(2) alm_w = -1j * alm_pm[1] * sqrt(2) ellmax = hp.sphtfunc.Alm.getlmax(len(alm_v)) ellArr, emmArr = hp.sphtfunc.Alm.getlm(ellmax) if args.chris: lctdir = "LCT_chris" else: lctdir = "LCT" if args.testrun: np.savez_compressed(f"/scratch/g.samarth/HMIDATA/" + f"{lctdir}/alm_test.npz", vlm=alm_v, wlm=alm_w)
def check_cl_sims( nmaps=1, lmax=1000, nside=2048, read_file=False, filename='testsky.fits', frequency=100, beam=None, beamP=None, smear=True, nonoise=False, cl_file='bf_base_cmbonly_plikHMv18_TT_lowTEB_lmax4000.minimum.theory_cl' ): if read_file and os.path.exists(data_path + filename): Tmap, Qmap, Umap = hp.read_map(data_path + filename, field=(0, 1, 2)) else: if nonoise: Tmap, Qmap, Umap = simulate_cmb(nside=nside, lmax=lmax, save=False, smear=smear, beam=beam, beamP=beamP, cl_file=cl_file) else: Tmap, Qmap, Umap = observe_cmb_sky(save=False, nside=nside, npix=None, lmax=3000, frequency=frequency, beam=beam, beamP=beamP, cl_file=cl_file) Tlm = hp.map2alm(Tmap, lmax=lmax) Elm, Blm = hp.map2alm_spin((Qmap, Umap), 2, lmax=lmax) if smear: if (beam is None) or (beamP is None): hdulist = fits.open(data_path + 'HFI_RIMO_Beams-100pc_R2.00.fits') beam = hdulist[beam_index['{}'.format( frequency)]].data.NOMINAL[0][:lmax + 1] beamP = hdulist[beam_index['{}P'.format( frequency)]].data.NOMINAL[0][:lmax + 1] hp.sphtfunc.almxfl(Tlm, 1. / beam, inplace=True) hp.sphtfunc.almxfl(Elm, 1. / beamP, inplace=True) hp.sphtfunc.almxfl(Blm, 1. / beamP, inplace=True) ls = np.arange(lmax + 1) factor = ls * (ls + 1.) / (2. * np.pi) cltt = hp.alm2cl(Tlm) * factor clee = hp.alm2cl(Elm) * factor clbb = hp.alm2cl(Blm) * factor clte = hp.alm2cl(Tlm, Elm) * factor cl = get_theory_cmb() ls_theory = cl[0][:lmax + 1] factor_theory = ls_theory * (ls_theory + 1.) / (2. * np.pi) cltt_theory = cl[1][:lmax + 1] * factor_theory clee_theory = cl[2][:lmax + 1] * factor_theory clbb_theory = cl[3][:lmax + 1] * factor_theory clte_theory = cl[4][:lmax + 1] * factor_theory plt.figure() plt.plot(ls, cltt, label='sims') plt.plot(ls_theory, cltt_theory, label='theory TT') plt.legend() plt.figure() plt.plot(ls, clte, label='sims') plt.plot(ls_theory, clte_theory, label='theory TE') plt.legend() plt.figure() plt.plot(ls, clee, label='sims') plt.plot(ls_theory, clee_theory, label='theory EE') plt.legend() plt.figure() plt.plot(ls, clbb, label='sims') plt.plot(ls_theory, clbb_theory, label='theory BB') plt.legend()
def measure_dlcl(mode='dl',frequency=353, mask=None, lmax=600,lmin=40, put_mask=True, psky=70, mask_sources=True, apodization=2, beam=None,beamP=None, Imap=None,Qmap=None,Umap=None, Imap2=None,Qmap2=None,Umap2=None, fsky_correction=True): """ If mode=='dl', returns D quantity = Cl *ls*(ls+1)/2./np.pi*1e12 [units: uK_CMB^2] """ if put_mask: if mask is None: print 'reading masks...' mask = pf.get_planck_mask(psky=psky, mask_sources=mask_sources, apodization=apodization) else: mask = map.copy()*0. + 1. if (beam is None) or (beamP is None): print 'reading beams...' beam_file = pf.PLANCK_DATA_PATH+'HFI_RIMO_Beams-100pc_R2.00.fits' hdulist = pf.fits.open(beam_file) beam = hdulist[pf.BEAM_INDEX['{}'.format(frequency)]].data.NOMINAL[0][:lmax+1] beamP = hdulist[pf.BEAM_INDEX['{}P'.format(frequency)]].data.NOMINAL[0][:lmax+1] beam = beam[lmin:lmax+1] beamP = beamP[lmin:lmax+1] fsky = mask.sum() / len(mask) ls = np.arange(lmin, lmax+1) if mode == 'dl': factor = ls * (ls+1) / (2.*np.pi) * 1e12 / fsky if mode == 'cl': factor = 1. / fsky if fsky_correction: fcfilename = pf.FGS_RESULTS_PATH + 'fskycorr_fg_psky{}_apo{}_lmax1000_TT_EE_BB.npy'.format(psky,apodization) if os.path.exists(fcfilename): fcorr = np.load(fcfilename) fcorr_TT = fcorr[0][lmin:lmax+1] fcorr_EE = fcorr[1][lmin:lmax+1] fcorr_BB = fcorr[2][lmin:lmax+1] else: fcorr = None else: fcorr = None if (Imap is None) or (Qmap is None) or (Umap is None): print 'reading maps...' mapname1 = pf.PLANCK_DATA_PATH + 'HFI_SkyMap_{}_2048_R2.02_halfmission-1.fits'.format(frequency) mapname2 = pf.PLANCK_DATA_PATH + 'HFI_SkyMap_{}_2048_R2.02_halfmission-2.fits'.format(frequency) Imap = hp.read_map(mapname1,field=0) Imap2 = hp.read_map(mapname2,field=0) Qmap, Umap = hp.read_map(mapname1,field=(1,2)) Qmap2, Umap2 = hp.read_map(mapname2,field=(1,2)) Tlm1 = hp.map2alm(Imap*mask, lmax=lmax) Elm1, Blm1 = hp.map2alm_spin( (Qmap*mask, Umap*mask), 2, lmax=lmax ) if (Imap2 is None) or (Qmap2 is None) or (Umap2 is None): Tlm2 = Tlm1 Elm2 = Elm1 Blm2 = Blm1 else: Tlm2 = hp.map2alm(Imap2*mask, lmax=lmax) Elm2, Blm2 = hp.map2alm_spin( (Qmap2*mask,Umap2*mask), 2, lmax=lmax ) TT = hp.alm2cl(Tlm1, Tlm2) EE = hp.alm2cl(Elm1, Elm2) BB = hp.alm2cl(Blm1, Blm2) EE = EE[lmin:] * factor / beamP**2 TT = TT[lmin:] * factor / beam**2 BB = BB[lmin:] * factor / beamP**2 TE = hp.alm2cl(Tlm1, Elm2) EB = hp.alm2cl(Blm1, Elm2) TB = hp.alm2cl(Blm1, Tlm2) TE = TE[lmin:] * factor / beam / beamP TB = TB[lmin:] * factor / beam / beamP EB = EB[lmin:] * factor / beamP**2 if fcorr is not None: TT *= fcorr_TT EE *= fcorr_EE BB *= fcorr_BB return ls, TT, EE, BB, TE, TB, EB
def map2alm_spin(maps, spin, lmax=None, mmax=None): assert spin >= 0, spin if spin > 0: return hp.map2alm_spin(maps, spin, lmax=lmax, mmax=mmax) else: return -hp.map2alm(maps[0], lmax=lmax, mmax=mmax, iter=0), 0.
def calc_TEB(Imap_name='HFI_SkyMap_353_2048_R2.02_full.fits', Pmap_name='HFI_SkyMap_353_2048_R2.02_full.fits', nus=None, fwhm=0.063, nside=16, lmax=100, lmaps_only=False, filename=None): """Master function for computing the bispectrum TEB """ # read from file if it's there if filename is None: filename = 'bispectrum_lmax{}'.format(lmax) if nus is not None: filename += '_{}-{}-{}GHz.npy'.format(nus[0], nus[1], nus[1]) else: filename += '_{}'.format(Imap_name[-5]) if Imap_name != Pmap_name: filename += '_{}.npy'.format(Pmap_name[-5]) else: filename += '.npy' print 'looking for {} ...'.format(filename) if os.path.exists(filename) and not lmaps_only: bispectrum = np.load(filename, 'r') return bispectrum # compute it, if the file doesn't exist if nus is not None: Imap_name = 'HFI_SkyMap_{}_2048_R2.02_full.fits'.format(nus[0]) Pmap_name = 'HFI_SkyMap_{}_2048_R2.02_full.fits'.format(nus[1]) title = '$I_{%i} P^2_{%i}$ (equilateral)' % (nus[0], nus[1]) Imap = prepare_map(Imap_name, field=0, nside_out=nside, fwhm=fwhm) Tlm = hp.map2alm(Imap, lmax=lmax) Qmap, Umap = prepare_map(Pmap_name, field=(1, 2), nside_out=nside, fwhm=fwhm) Elm, Blm = hp.map2alm_spin((Qmap, Umap), 2, lmax=lmax) if lmax is None: lmax = hp.sphtfunc.Alm.getlmax(len(Tlm)) ls, ms = hp.sphtfunc.Alm.getlm(lmax, np.arange(len(Tlm))) lmin = ls.min() mapsize = len(Imap) pixelsize = hp.pixelfunc.nside2pixarea(nside) Ylm = calc_Ylm(Imap, ls, ms) #return Ylm, Tlm, ls, ms print 'calculating Tl,El,Bl ...' Tl = sum_over_m(Tlm, Ylm, ls, lmax=lmax, lmin=lmin, mapsize=mapsize) El = sum_over_m(Elm, Ylm, ls, lmax=lmax, lmin=lmin, mapsize=mapsize) Bl = sum_over_m(Blm, Ylm, ls, lmax=lmax, lmin=lmin, mapsize=mapsize) if lmaps_only: return Tl, El, Bl hs = get_hs(lmin=lmin, lmax=lmax) print 'calculating bispectrum ...' bispectrum = calc_bispectrum(Tl, El, Bl, hs, pixelsize, lmax=lmax, lmin=lmin, mapsize=mapsize) clean_bispectrum_of_naninf(bispectrum, hs, inplace=True) np.save(filename, bispectrum) return bispectrum
def measure_dlcl(mode='dl', frequency=353, mask=None, lmax=600, lmin=40, put_mask=True, psky=70, mask_sources=True, apodization=2, beam=None, beamP=None, Imap=None, Qmap=None, Umap=None, Imap2=None, Qmap2=None, Umap2=None, fsky_correction=True): """ If mode=='dl', returns D quantity = Cl *ls*(ls+1)/2./np.pi*1e12 [units: uK_CMB^2] """ if put_mask: if mask is None: print 'reading masks...' mask = pf.get_planck_mask(psky=psky, mask_sources=mask_sources, apodization=apodization) else: mask = map.copy() * 0. + 1. if (beam is None) or (beamP is None): print 'reading beams...' beam_file = pf.PLANCK_DATA_PATH + 'HFI_RIMO_Beams-100pc_R2.00.fits' hdulist = pf.fits.open(beam_file) beam = hdulist[pf.BEAM_INDEX['{}'.format( frequency)]].data.NOMINAL[0][:lmax + 1] beamP = hdulist[pf.BEAM_INDEX['{}P'.format( frequency)]].data.NOMINAL[0][:lmax + 1] beam = beam[lmin:lmax + 1] beamP = beamP[lmin:lmax + 1] fsky = mask.sum() / len(mask) ls = np.arange(lmin, lmax + 1) if mode == 'dl': factor = ls * (ls + 1) / (2. * np.pi) * 1e12 / fsky if mode == 'cl': factor = 1. / fsky if fsky_correction: fcfilename = pf.FGS_RESULTS_PATH + 'fskycorr_fg_psky{}_apo{}_lmax1000_TT_EE_BB.npy'.format( psky, apodization) if os.path.exists(fcfilename): fcorr = np.load(fcfilename) fcorr_TT = fcorr[0][lmin:lmax + 1] fcorr_EE = fcorr[1][lmin:lmax + 1] fcorr_BB = fcorr[2][lmin:lmax + 1] else: fcorr = None else: fcorr = None if (Imap is None) or (Qmap is None) or (Umap is None): print 'reading maps...' mapname1 = pf.PLANCK_DATA_PATH + 'HFI_SkyMap_{}_2048_R2.02_halfmission-1.fits'.format( frequency) mapname2 = pf.PLANCK_DATA_PATH + 'HFI_SkyMap_{}_2048_R2.02_halfmission-2.fits'.format( frequency) Imap = hp.read_map(mapname1, field=0) Imap2 = hp.read_map(mapname2, field=0) Qmap, Umap = hp.read_map(mapname1, field=(1, 2)) Qmap2, Umap2 = hp.read_map(mapname2, field=(1, 2)) Tlm1 = hp.map2alm(Imap * mask, lmax=lmax) Elm1, Blm1 = hp.map2alm_spin((Qmap * mask, Umap * mask), 2, lmax=lmax) if (Imap2 is None) or (Qmap2 is None) or (Umap2 is None): Tlm2 = Tlm1 Elm2 = Elm1 Blm2 = Blm1 else: Tlm2 = hp.map2alm(Imap2 * mask, lmax=lmax) Elm2, Blm2 = hp.map2alm_spin((Qmap2 * mask, Umap2 * mask), 2, lmax=lmax) TT = hp.alm2cl(Tlm1, Tlm2) EE = hp.alm2cl(Elm1, Elm2) BB = hp.alm2cl(Blm1, Blm2) EE = EE[lmin:] * factor / beamP**2 TT = TT[lmin:] * factor / beam**2 BB = BB[lmin:] * factor / beamP**2 TE = hp.alm2cl(Tlm1, Elm2) EB = hp.alm2cl(Blm1, Elm2) TB = hp.alm2cl(Blm1, Tlm2) TE = TE[lmin:] * factor / beam / beamP TB = TB[lmin:] * factor / beam / beamP EB = EB[lmin:] * factor / beamP**2 if fcorr is not None: TT *= fcorr_TT EE *= fcorr_EE BB *= fcorr_BB return ls, TT, EE, BB, TE, TB, EB
def g2eb(g1, g2): nside = gnside(g1) (ae, ab) = hp.map2alm_spin((g1, g2), 2) ke = hp.alm2map(ae, nside, pol=False) kb = hp.alm2map(ab, nside, pol=False) return ke, kb