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 alm2map_spin_der1(gclm, nside, spin, zbounds=(-1.0, 1.0), ret_slice=None): """Returns spin-s transform '_{s}d' of alm, together with d/dtheta _{s}d and 1/sin tht d/dphi _{s}d. This crude version has three calls to spin-weight harmonics alm2map_spin. Author: Julien Carron ([email protected]) """ assert spin > 0, spin assert hp.Alm.getlmax(gclm[0].size) == hp.Alm.getlmax(gclm[1].size) lmax = hp.Alm.getlmax(gclm[0].size) zbounds = np.sort(np.array(zbounds)) # shape (2, 12 * nside ** 2), # first entry = real part, second entry imaginary part. _sd = np.array(hp.alm2map_spin(gclm, nside, spin, lmax)) if spin > 1: _gclm = [ hp.almxfl(gclm[0], get_alpha_lower(spin, lmax)), hp.almxfl(gclm[1], get_alpha_lower(spin, lmax)), ] _sm1d = np.array(hp.alm2map_spin(_gclm, nside, spin - 1, lmax)) else: _sm1d = -np.array( [ hp.alm2map( hp.almxfl(gclm[0], get_alpha_lower(spin, lmax)), nside, verbose=False, ), hp.alm2map( hp.almxfl(gclm[1], get_alpha_lower(spin, lmax)), nside, verbose=False, ), ] ) _gclm = [ hp.almxfl(gclm[0], get_alpha_raise(spin, lmax)), hp.almxfl(gclm[1], get_alpha_raise(spin, lmax)), ] _sp1d = np.array(hp.alm2map_spin(_gclm, nside, spin + 1, lmax)) d_dth = -0.5 * (_sp1d + _sm1d) d_dphi_sin0 = 0.5 * np.array([-_sp1d[1] + _sm1d[1], _sp1d[0] - _sm1d[0]]) for iring in range(4 * nside - 1): startpix, nphi, kphi0, cth, sth = get_healpix_ring_pixel_layout(nside, iring) if zbounds[0] <= cth <= zbounds[1]: slic = slice(startpix, startpix + nphi) d_dphi_sin0[1, slic] -= spin * (cth / sth) * _sd[0, slic] d_dphi_sin0[0, slic] += spin * (cth / sth) * _sd[1, slic] if ret_slice is not None: return _sd[:, ret_slice], d_dth[:, ret_slice], d_dphi_sin0[:, ret_slice] return _sd, d_dth, d_dphi_sin0
def get_gpmap(self, idx, spin, k=None, xfilt=None): """ \sum_{lm} (Elm +- iBlm) sqrt(l+2 (l-1)) _1 Ylm(n). sqrt(l-2 (l+3)) _3 Ylm(n). Output is list with real and imaginary part of the spin 1 or 3 transforms. """ assert k in ['p_p', 'p'], k assert spin in [1, 3] if xfilt is not None: assert isinstance(xfilt, dict) and 'e' in xfilt.keys( ) and 'b' in xfilt.keys() and 't' in xfilt.keys() need_p = (xfilt is None) or (np.any(xfilt['e']) or np.any(xfilt['b'])) Glm, Clm = (self.ivfs.get_sim_emliklm(idx), self.ivfs.get_sim_bmliklm(idx)) if need_p else (0., 0.) if xfilt is not None and need_p: hp.almxfl(Glm, xfilt['e'], inplace=True) hp.almxfl(Clm, xfilt['b'], inplace=True) if k == 'p': need_t = (xfilt is None) or np.any(xfilt['t']) G_tlm = hp.almxfl(self.ivfs.get_sim_tlm(idx), self.clte) if need_t else 0. if xfilt is not None and need_t: hp.almxfl(G_tlm, xfilt['t'], inplace=True) Glm = Glm + G_tlm del G_tlm if np.any(Glm) or np.any(Clm): lmax = hp.Alm.getlmax(Glm.size) if spin == 1: fl = np.arange(2, lmax + 3, dtype=float) * (np.arange( -1, lmax)) elif spin == 3: fl = np.arange(-2, lmax - 1, dtype=float) * (np.arange( 3, lmax + 4)) else: assert 0 fl[:spin] *= 0. fl = np.sqrt(fl) hp.almxfl(Glm, fl, inplace=True) if np.any(Clm): hp.almxfl(Clm, fl, inplace=True) if np.isscalar(Clm): return hp.alm2map_spin([Glm, Glm * 0.], self.nside, spin, lmax) else: return hp.alm2map_spin([Glm, Clm], self.nside, spin, lmax) else: return np.zeros(hp.nside2npix(self.nside), dtype=float), np.zeros(hp.nside2npix(self.nside), dtype=float)
def simulate_cmb(nside=2048, lmax=3000, frequency=100,smear=False, nomap = False, beam=None, beamP=None, save=False, filename='testcmb.fits', cl_file='bf_base_cmbonly_plikHMv18_TT_lowTEB_lmax4000.minimum.theory_cl'): ls, cltt, clte, clee, clbb = get_theory_cls(lmax=lmax, cl_file=cl_file) Tlm, Elm, Blm = hp.synalm( (cltt, clee, clbb, clte), new=True, 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, beam, inplace=True) hp.sphtfunc.almxfl(Elm, beamP, inplace=True) hp.sphtfunc.almxfl(Blm, beamP, inplace=True) if nomap: return Tlm,Elm,Blm Tmap = hp.alm2map( Tlm, nside ) Qmap, Umap = hp.alm2map_spin( (Elm, Blm), nside, 2, lmax=lmax) if save: hp.write_map([Tmap,Qmap,Umap],data_path + filename) return Tmap, Qmap, Umap
def test_alm2map_spin_precomputed(self): """ compare alm2map_spin outputs to some precomputed results for spin=1,2,3 """ for spin in [1,2,3]: rmap, imap = hp.alm2map_spin( [galm, calm], nside_precomputed, spin, lmax_precomputed ) np.testing.assert_array_almost_equal( rmap, maps[spin].real, decimal=7) np.testing.assert_array_almost_equal( imap, maps[spin].imag, decimal=7)
def get_gpmap(self, idx, spin, k=None, xfilt=None): """ \sum_{lm} (Elm +- iBlm) sqrt(l+2 (l-1)) _1 Ylm(n). sqrt(l-2 (l+3)) _3 Ylm(n). Output is list with real and imaginary part of the spin 1 or 3 transforms. """ assert spin in [1, 3] assert xfilt is None, 'not implemented' Glm = self.ivfs.get_sim_emliklm(idx) Clm = self.ivfs.get_sim_bmliklm(idx) assert Glm.size == Clm.size, (Clm.size, Clm.size) lmax = hp.Alm.getlmax(Glm.size) if spin == 1: fl = np.arange(2, lmax + 3, dtype=float) * (np.arange(-1, lmax)) elif spin == 3: fl = np.arange(-2, lmax - 1, dtype=float) * (np.arange( 3, lmax + 4)) else: assert 0 fl[:spin] *= 0. fl = np.sqrt(fl) hp.almxfl(Glm, fl, inplace=True) hp.almxfl(Clm, fl, inplace=True) return hp.alm2map_spin([Glm, Clm], self.nside, spin, lmax)
def eb2g(ke, kb): nside = gnside(ke) lmax = nside * 3 - 1 ae = hp.map2alm(ke, 1, pol=False) ab = hp.map2alm(kb, 1, pol=False) (g1, g2) = hp.alm2map_spin((ae, ab), nside, 2, lmax) return g1, g2
def test_t(): lmax = 200 nside = 256 cls_unl = np.ones(lmax + 1, dtype=float) tunl = hp.synalm(cls_unl, new=True) dlm = np.zeros_like(tunl) hp.almxfl(dlm, np.sqrt( np.arange(lmax + 1) * np.arange(1, lmax + 2, dtype=float)), inplace=True) T = hp.alm2map(tunl, nside) T1 = lensing.alm2lenmap(tunl, [dlm, None], nside, verbose=True, nband=8, facres=-2) assert np.max(np.abs(T - T1)) / np.std(T) < 1e-5 d1Re, d1Im = hp.alm2map_spin([dlm, np.zeros_like(dlm)], nside, 1, lmax) T2 = lensing.alm2lenmap(tunl, [d1Re, d1Im], nside, verbose=True, nband=8, facres=-2) assert np.max(np.abs(T - T2)) / np.std(T) < 1e-5 T3 = lensing.alm2lenmap(tunl, [dlm, dlm.copy()], nside, verbose=True, nband=8, facres=-2) assert np.all(T2 == T3)
def alm2map_spin(gclm, nside, spin, lmax, mmax=None): assert spin >= 0, spin assert len(gclm) == 2, len(gclm) if spin > 0: return hp.alm2map_spin(gclm, nside, spin, lmax, mmax=mmax) elif spin == 0: return hp.alm2map(-gclm[0], nside, lmax=lmax, mmax=mmax), 0.
def get_gtmap(self, idx, k=None, xfilt=None): """ \sum_{lm} MAP_talm sqrt(l (l + 1)) _1 Ylm(n). Spin 1 transform with zero curl comp. Recall healpy sign convention for which Glm = - Tlm. Output is list with real and imaginary part of the spin 1 transform. """ assert k in ['ptt', 'p'], k if xfilt is not None: assert isinstance(xfilt, dict) and 't' in xfilt.keys() mliktlm = self.ivfs.get_sim_tmliklm(idx) if xfilt is not None: hp.almxfl(mliktlm, xfilt['t'], inplace=True) if k == 'p': telm = hp.almxfl(self.ivfs.get_sim_elm(idx), self.clte) if xfilt is not None: assert 'e' in xfilt.keys() hp.almxfl(telm, xfilt['e'], inplace=True) mliktlm += telm del telm lmax = hp.Alm.getlmax(mliktlm.size) Glm = hp.almxfl( mliktlm, -np.sqrt( np.arange(lmax + 1, dtype=float) * (np.arange(1, lmax + 2)))) return hp.alm2map_spin([Glm, np.zeros_like(Glm)], self.nside, 1, lmax)
def test_spin0(self): m1 = hp.alm2map(self.almg, self.nside, self.lmax) m2_r, m2_i = hp.alm2map_spin([self.almg, 0. * self.almg], self.nside, 0, self.lmax) np.testing.assert_array_almost_equal(m1, m2_r, decimal=8) np.testing.assert_array_almost_equal(m1 * 0., m2_i, decimal=8)
def get_pmap(self, idx): """Real-space Wiener filtered polarization. """ Glm = self.ivfs.get_sim_emliklm(idx) Clm = self.ivfs.get_sim_bmliklm(idx) return hp.alm2map_spin([Glm, Clm], self.nside, 2, hp.Alm.getlmax(Glm.size))
def get_gpmap(self, idx, spin, k=None, xfilt=None): """ \sum_{lm} (Elm +- iBlm) sqrt(l+2 (l-1)) _1 Ylm(n). sqrt(l-2 (l+3)) _3 Ylm(n). Output is list with real and imaginary part of the spin 1 or 3 transforms. """ assert k in ['p_p', 'p'], k assert spin in [1, 3] if xfilt is not None: assert isinstance(xfilt, dict) and 'e' in xfilt.keys() and 'b' in xfilt.keys() and 't' in xfilt.keys() Glm = self.ivfs.get_sim_emliklm(idx) Clm = self.ivfs.get_sim_bmliklm(idx) if xfilt is not None: hp.almxfl(Glm, xfilt['e'], inplace=True) hp.almxfl(Clm, xfilt['b'], inplace=True) if k == 'p': G_tlm = hp.almxfl(self.ivfs.get_sim_tlm(idx), self.clte) if xfilt is not None: hp.almxfl(G_tlm, xfilt['t'], inplace=True) Glm += G_tlm del G_tlm assert Glm.size == Clm.size, (Clm.size, Clm.size) lmax = hp.Alm.getlmax(Glm.size) if spin == 1: fl = np.arange(2, lmax + 3, dtype=float) * (np.arange(-1, lmax)) elif spin == 3: fl = np.arange(-2, lmax - 1, dtype=float) * (np.arange(3, lmax + 4)) else: assert 0 fl[:spin] *= 0. fl = np.sqrt(fl) hp.almxfl(Glm, fl, inplace=True) hp.almxfl(Clm, fl, inplace=True) return hp.alm2map_spin([Glm, Clm], self.nside, spin, lmax)
def get_def_hp(nside,dlm,th1,th2): # FIXME band only calc. with vtm ? pix = hp.query_strip(nside, max(th1, 0.), min(np.pi, th2), inclusive=True) Red, Imd = hp.alm2map_spin([dlm, np.zeros_like(dlm)], nside, 1, hp.Alm.getlmax(dlm.size)) Red = Red[pix] Imd = Imd[pix] return _buildangles(hp.pix2ang(nside, pix),Red[pix],Imd[pix])
def get_sim_qumap(self,idx): elm = self.sims_cmb_len.get_sim_elm(idx) hp.almxfl(elm,self.cl_ptransf,inplace=True) blm = self.sims_cmb_len.get_sim_blm(idx) hp.almxfl(blm, self.cl_ptransf, inplace=True) Q,U = hp.alm2map_spin([elm,blm], self.nside, 2,hp.Alm.getlmax(elm.size)) del elm,blm return [Q + self.get_sim_qnoise(idx),U + self.get_sim_unoise(idx)]
def get_pmap(self, idx, joint=False): """Real-space Wiener filtered polarization. """ Glm = self.ivfs.get_sim_emliklm(idx) Clm = self.ivfs.get_sim_bmliklm(idx) if joint: Glm += hp.almxfl(self.ivfs.get_sim_tlm(idx), self.clte) return hp.alm2map_spin([Glm, Clm], self.nside, 2, hp.Alm.getlmax(Glm.size))
def get_sim_pmap(self, idx): elm = hp.almxfl(cmb_len_ffp10.get_sim_elm(idx), self.transf) blm = hp.almxfl(cmb_len_ffp10.get_sim_blm(idx), self.transf) Q, U = hp.alm2map_spin((elm, blm), self.nside, 2, hp.Alm.getlmax(elm.size)) del elm, blm nlevp_pix = self.nlevp / np.sqrt(hp.nside2pixarea(self.nside, degrees=True)) / 60. Q += self.pix_libphas.get_sim(idx, idf=1) * nlevp_pix U += self.pix_libphas.get_sim(idx, idf=2) * nlevp_pix return Q, U
def test_der1(self): """ compare output of alm2map_der1 with the equivalent spin-1 transform using alm2map_spin """ m, dt_der1, dp_der1 = hp.alm2map_der1( self.almg, self.nside ) alm_spin = hp.almxfl( self.almg, np.array( [np.sqrt(l*(l+1.)) for l in six.moves.xrange(0,self.lmax+1)] ), inplace=False ) dt_spin, dp_spin = hp.alm2map_spin( [alm_spin, alm_spin*0.], self.nside, 1, self.lmax ) np.testing.assert_array_almost_equal( dt_der1, dt_spin, decimal=8) np.testing.assert_array_almost_equal( dp_der1, dp_spin, decimal=8)
def get_irespmap(self, idx, xfilt=None): reselm = self.ivfs.get_sim_elm(idx) resblm = self.ivfs.get_sim_blm(idx) assert hp.Alm.getlmax(reselm.size) == hp.Alm.getlmax(resblm.size) if xfilt is not None: assert isinstance(xfilt, dict) and 'e' in xfilt.keys() and 'b' in xfilt.keys() hp.almxfl(reselm, xfilt['e'], inplace=True) hp.almxfl(resblm, xfilt['b'], inplace=True) fac = 0.5 return hp.alm2map_spin([reselm * fac, resblm * fac], self.nside, 2, hp.Alm.getlmax(reselm.size))
def test_der1(self): """ compare output of alm2map_der1 with the equivalent spin-1 transform using alm2map_spin """ m, dt_der1, dp_der1 = hp.alm2map_der1( self.almg, self.nside ) alm_spin = hp.almxfl( self.almg, np.array( [np.sqrt(l*(l+1.)) for l in xrange(0,self.lmax+1)] ), inplace=False ) dt_spin, dp_spin = hp.alm2map_spin( [alm_spin, alm_spin*0.], self.nside, 1, self.lmax ) np.testing.assert_array_almost_equal( dt_der1, dt_spin, decimal=8) np.testing.assert_array_almost_equal( dp_der1, dp_spin, decimal=8)
def test_pol(): lmax = 200 nside = 256 facres = -1 cls_unl = np.ones(lmax + 1, dtype=float) tunl = hp.synalm(cls_unl, new=True) dlm = np.zeros_like(tunl) hp.almxfl(dlm, np.sqrt( np.arange(lmax + 1) * np.arange(1, lmax + 2, dtype=float)), inplace=True) Q, U = hp.alm2map_spin([tunl, np.zeros_like(tunl)], nside, 2, lmax) Q1, U1 = lensing.alm2lenmap_spin([tunl, None], [dlm, None], nside, 2, verbose=True, nband=8, facres=facres) assert np.max(np.abs(Q - Q1)) / np.std(Q) < 1e-5, np.max( np.abs(Q - Q1)) / np.std(Q) assert np.max(np.abs(U - U1)) / np.std(U) < 1e-5, np.max( np.abs(U - U1)) / np.std(U) d1Re, d1Im = hp.alm2map_spin([dlm, np.zeros_like(dlm)], nside, 1, lmax) Q2, U2 = lensing.alm2lenmap_spin([tunl, None], [d1Re, d1Im], nside, 2, verbose=True, nband=8, facres=facres) assert np.allclose(Q2, Q1, rtol=1e-10) assert np.allclose(U2, U1, rtol=1e-10) Q3, U3 = lensing.alm2lenmap_spin([tunl, tunl * 0.], [d1Re, d1Im], nside, 2, verbose=True, nband=8, facres=facres) assert np.all(Q3 == Q2) assert np.all(U3 == U2)
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 alm2map(self,alm,spin,ncomp,mlmax): if self.hpix: if spin!=0: res = hp.alm2map_spin(alm,nside=self.nside,spin=spin,lmax=mlmax) return res else: # complex64 not supported here return hp.alm2map(alm.astype(np.complex128),nside=self.nside,pol=False)[None] else: omap = enmap.empty((ncomp,)+self.shape,self.wcs,dtype=self.dtype) return cs.alm2map(alm,omap,spin=spin)
def get_gtmap(self, idx, k=None, xfilt=None): """ \sum_{lm} MAP_talm sqrt(l (l + 1)) _1 Ylm(n). Spin 1 transform with zero curl comp. Recall healpy sign convention for which Glm = - Tlm. Output is list with real and imaginary part of the spin 1 transform. """ assert xfilt is None, 'not implemented' mliktlm = self.ivfs.get_sim_tmliklm(idx) lmax = hp.Alm.getlmax(mliktlm.size) Glm = hp.almxfl(mliktlm, -np.sqrt(np.arange(lmax + 1, dtype=float) * (np.arange(1, lmax + 2)))) return hp.alm2map_spin([Glm, np.zeros_like(Glm)], self.nside, 1, lmax)
def window2vecttens(window_scal, mask=None, lmax=None, mmax=None): ''' Calculates the vector/tensor windows needed in the pure Cl calculation Notes ----- We calculate both straight from the wlms of the scalar window because calculating the spin-2 from the spherical harmonic transform of a spin-1 window will result in larger errors. If you don't want zero pixels to be masked out input a full sky mask. ''' nside = H.npix2nside(len(window_scal)) if mask is None: mask = np.ones_like(window_scal) #mask[window_scal == 0] = 0 else: window_scal = window_scal * mask wlm = H.map2alm(window_scal, lmax=lmax, mmax=mmax) if lmax is None: lmax = H.Alm.getlmax(len(wlm)) spin = 1 wlm_tmp = wlm_scalar2spin(wlm, spin) window_vect = H.alm2map_spin(wlm_tmp, nside, spin, lmax, mmax=mmax) window_vect[0] *= mask window_vect[1] *= mask spin = 2 wlm_tmp = wlm_scalar2spin(wlm, spin) window_tens = H.alm2map_spin(wlm_tmp, nside, spin, lmax, mmax=mmax) window_tens[0] *= mask window_tens[1] *= mask return window_vect, window_tens
def make_maps( a3darraymap ): # a function that makes maps from gamma 1 and gamma 2 shear measurements - needs a 3d array of an empty map, a g1 map and a g2map NSIDE = hp.npix2nside(len( a3darraymap[1])) #finds nside of a map from just input map LMAX = 2 * NSIDE - 1 ells = hp.sphtfunc.Alm.getsize(lmax=LMAX) lmode = np.zeros(ells) for jh in range(0, ells): lmode[jh] = hp.sphtfunc.Alm.getlm( lmax=LMAX, i=jh)[0] #puts ell modes in an array, doesnt need to be a loop lfacsphi = -2 / np.sqrt( (lmode + 2) * (lmode + 1) * (lmode) * (lmode - 1) ) #ell mode coefficients to go from E_alm to gravitational potential lfacsphi[np.where(lmode < 2)] = 0 lfacsphi[np.isnan(lfacsphi)] = 0 lfacsphi[np.isinf(lfacsphi)] = 0 lfacskappa = (lmode * (lmode + 1) * ((lmode + 2)**-1) * ((lmode - 1)**-1) )**0.5 ##ell mode coefficients to go from E_alm to kappa lfacskappa[np.where(lmode < 2)] = 0 lfacskappa[np.isinf(lfacskappa)] = 0 lfacskappa[np.isnan(lfacskappa)] = 0 ## SY 30/5/18 Added minus sign below alphafacs = -2 / np.sqrt( (lmode + 2) * (lmode - 1)) #ell mode coefficients to go from E_alm to alpha, bend angle alms = hp.sphtfunc.map2alm(a3darraymap, lmax=LMAX, pol=True) Ealm = alms[1] Kalm = lfacskappa * Ealm Palm = lfacsphi * Ealm alphaplus = alphafacs * alms[2] alphaminus = alphafacs * alms[1] alphaplus[np.where(lmode < 2)] = 0 alphaminus[np.where(lmode < 2)] = 0 #2 different bend angles. Kmap = hp.sphtfunc.alm2map(Kalm, nside=NSIDE, lmax=LMAX) Pmap = hp.sphtfunc.alm2map(Palm, nside=NSIDE, lmax=LMAX) Amap = hp.alm2map_spin( [alphaplus, alphaminus], nside=NSIDE, spin=1, lmax=LMAX) # spin1 transform to get the 2 bend angles return Kmap, Pmap, Amap
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 get_sim_pmap(self,idx): """Returns polarization healpy maps for a simulation Args: idx: simulation index Returns: Q and U healpy maps """ elm = self.sims_cmb_len.get_sim_elm(idx) hp.almxfl(elm,self.cl_transf,inplace=True) blm = self.sims_cmb_len.get_sim_blm(idx) hp.almxfl(blm, self.cl_transf, inplace=True) Q,U = hp.alm2map_spin([elm,blm], self.nside, 2,hp.Alm.getlmax(elm.size)) del elm,blm return Q + self.get_sim_qnoise(idx),U + self.get_sim_unoise(idx)
def make_maps(a3darraymap): '''a function that makes maps from gamma 1 and gamma 2 shear measurements - needs a 3d array of an empty map, a g1 map and a g2map ''' #finds nside of a map from just input map nside = hp.npix2nside(len(a3darraymap[1])) lmax = 2 * nside - 1 nell = hp.sphtfunc.Alm.getsize(lmax=lmax) #puts ell modes in an array, doesnt need to be a loop lmode = hp.sphtfunc.Alm.getlm(lmax=lmax, i=np.arange(nell))[0] #-- get alm from input map alms = hp.sphtfunc.map2alm(a3darraymap, lmax=lmax, pol=True) #ell mode coefficients to go from E_alm to gravitational potential lfactor_phi = -2 / np.sqrt( (lmode + 2) * (lmode + 1) * (lmode) * (lmode - 1)) lfactor_phi[lmode < 2] = 0 ##ell mode coefficients to go from E_alm to kappa lfactor_kappa = lmode * (lmode + 1) / (lmode + 2) / np.sqrt(lmode - 1) lfactor_kappa[lmode < 2] = 0 ## SY 30/5/18 Added minus sign below #ell mode coefficients to go from E_alm to alpha, bend angle lfactor_alpha = -2 / np.sqrt((lmode + 2) * (lmode - 1)) lfactor_alpha[lmode < 2] = 0 weird_alm = lfactor_kappa * alms[1] phi_alm = lfactor_phi * alms[1] alphaminus_alm = lfactor_alpha * alms[1] alphaplus_alm = lfactor_alpha * alms[2] weird_map = hp.sphtfunc.alm2map(kappa_alm, nside=nside, lmax=lmax) phi_map = hp.sphtfunc.alm2map(phi_alm, nside=nside, lmax=lmax) # -- spin1 transform to get the 2 bend angles alpha_map = hp.alm2map_spin([alphaplus_alm, alphaminus_alm], nside=nside, spin=1, lmax=lmax) return weird_map, phi_map, alpha_map
def simulate(self, det, idx): assert( det in (dmc.wmap_das + dmc.wmap_bands) ) tlm = self.sim_teblm_cmb.get_sim_tlm(idx) elm = self.sim_teblm_cmb.get_sim_elm(idx) blm = self.sim_teblm_cmb.get_sim_blm(idx) hp.almxfl(tlm, self.get_beam(det), inplace=True) hp.almxfl(elm, self.get_beam(det), inplace=True) hp.almxfl(blm, self.get_beam(det), inplace=True) tmap = hp.alm2map(tlm, self.nside) qmap, umap = hp.alm2map_spin( (elm, blm), self.nside, 2, lmax=self.lmax ) tmap_nse, qmap_nse, umap_nse = self.simulate_nse(det) tmap += tmap_nse; del tmap_nse qmap += qmap_nse; del qmap_nse umap += umap_nse; del umap_nse return tmap, (qmap + 1.j*umap)
def simulate(self, det, idx): assert(det == '') tlm = self.sim_teblm_cmb.get_sim_tlm(idx) elm = self.sim_teblm_cmb.get_sim_elm(idx) blm = self.sim_teblm_cmb.get_sim_blm(idx) beam = self.bl[0:self.lmax+1] * hp.pixwin(self.nside)[0:self.lmax+1] hp.almxfl(tlm, beam, inplace=True) hp.almxfl(elm, beam, inplace=True) hp.almxfl(blm, beam, inplace=True) tmap = hp.alm2map(tlm, self.nside) qmap, umap = hp.alm2map_spin( (elm, blm), self.nside, 2, lmax=self.lmax ) npix = 12*self.nside**2 tmap += np.random.standard_normal(npix) * (self.noiseT_uK_arcmin * np.sqrt(npix / 4. / np.pi) * np.pi / 180. / 60.) qmap += np.random.standard_normal(npix) * (self.noiseP_uK_arcmin * np.sqrt(npix / 4. / np.pi) * np.pi / 180. / 60.) umap += np.random.standard_normal(npix) * (self.noiseP_uK_arcmin * np.sqrt(npix / 4. / np.pi) * np.pi / 180. / 60.) return tmap, qmap + 1.j*umap
def simulate_map(alms, nside=2048, lmax=2000, frequency=100,smear=False, beam=None, beamP=None, beam_file=PLANCK_DATA_PATH+'HFI_RIMO_Beams-100pc_R2.00.fits'): Tlm = alms[0] Elm = alms[1] Blm = alms[2] if smear: if (beam is None) or (beamP is None) : hdulist = fits.open(beam_file) 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, beam, inplace=True) hp.sphtfunc.almxfl(Elm, beamP, inplace=True) hp.sphtfunc.almxfl(Blm, beamP, inplace=True) Tmap = hp.alm2map( Tlm, nside, verbose=False ) Qmap, Umap = hp.alm2map_spin( (Elm, Blm), nside, 2, lmax=lmax) return Tmap, Qmap, Umap
def alm2map_spin(self,alm,spin_alm,spin_transform,ncomp,mlmax): """ Returns X(n) = sum_lm alm_s1 s2_Y_lm(n) where s1=spin_alm and s2=spin_transform are different spins. alm should be (alm_+|s|, alm_-|s|) """ # Transform (alm_+|s|, alm_-|s|) to (alm_+, alm_-) ap_am = irot2d(alm,spin=spin_alm) if self.hpix: res = hp.alm2map_spin(ap_am,nside=self.nside,spin=abs(spin_transform),lmax=mlmax) else: omap = enmap.empty((ncomp,)+self.shape[-2:],self.wcs,dtype=self.dtype) res = cs.alm2map(ap_am,omap,spin=abs(spin_transform)) # Rotate maps M+ and M- to M_+|s| and M_-|s| # M_+|s| is the first component # M_-|s| is the second component return rot2d(res)
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 lens_glm_sym(spin,dlm,glm,nside,nband = 32,facres = 0,clm = None,rotpol = True): """ Same as lens_alm but lens simultnously a North and South colatitude band, to make profit of the symmetries of the spherical harmonics. Note that tlm = -glm in the spin 0 case. """ target_nt = 3 ** 1 * 2 ** (11 + facres) th1s = np.arange(nband) * (np.pi * 0.5 / nband) th2s = np.concatenate((th1s[1:],[np.pi * 0.5])) Nt_perband = target_nt / nband Redtot, Imdtot = hp.alm2map_spin([dlm, np.zeros_like(dlm)], nside, 1, hp.Alm.getlmax(dlm.size)) ret = np.zeros(hp.nside2npix(nside),dtype = float if spin == 0 else complex) for th1,th2 in zip(th1s,th2s): pixN = hp.query_strip(nside, th1, th2, inclusive=True) pixS = hp.query_strip(nside, np.pi- th2,np.pi - th1, inclusive=True) tnewN,phinewN = _buildangles(hp.pix2ang(nside, pixN),Redtot[pixN],Imdtot[pixN]) tnewS,phinewS = _buildangles(hp.pix2ang(nside, pixS), Redtot[pixS], Imdtot[pixS]) matnewN = np.max(tnewN) mitnewN = np.min(tnewN) matnewS = np.max(tnewS) mitnewS = np.min(tnewS) buffN = 10 * (matnewN - mitnewN) / (Nt_perband - 1) / (1. - 2. * 10. / (Nt_perband - 1)) buffS = 10 * (matnewS - mitnewS) / (Nt_perband - 1) / (1. - 2. * 10. / (Nt_perband - 1)) thup = min(np.pi - (matnewS + buffS),mitnewN - buffN) thdown = max(np.pi - (mitnewS - buffS),matnewN + buffN) if spin == 0: lenN,lenS = lens_band_sym(glm,thup,thdown,Nt_perband,(tnewN,phinewN),(tnewS,phinewS), Nphi=get_Nphi(thup, thdown, facres=facres)) ret[pixN] = lenN ret[pixS] = lenS else : lenNR,lenNI,lenSR,lenSI = lens_gcband_sym(spin,glm,thup,thdown, Nt_perband,(tnewN,phinewN),(tnewS,phinewS), Nphi=get_Nphi(thup, thdown, facres=facres),clm = clm) ret[pixN] = lenNR + 1j * lenNI ret[pixS] = lenSR + 1j * lenSI if rotpol : ret[pixN] *= polrot(spin,ret[pixN], hp.pix2ang(nside, pixN)[0],Redtot[pixN],Imdtot[pixN]) ret[pixS] *= polrot(spin,ret[pixS], hp.pix2ang(nside, pixS)[0],Redtot[pixS],Imdtot[pixS]) return ret
def test_spin0(self): m1 = hp.alm2map( self.almg, self.nside, self.lmax ) m2_r, m2_i = hp.alm2map_spin( [self.almg, 0.*self.almg], self.nside, 0, self.lmax ) np.testing.assert_array_almost_equal( m1, m2_r, decimal=8) np.testing.assert_array_almost_equal( m1*0., m2_i, decimal=8)