def test_almxfl(self):
import healpy as hp
for lmax in [100, 400, 500, 1000]:
ainfo = sharp.alm_info(lmax)
alms = hp.synalm(np.ones(lmax + 1), lmax=lmax)
filtering = np.ones(lmax + 1)
alms0 = ainfo.lmul(alms.copy(), filtering)
assert np.all(np.isclose(alms0, alms))
for lmax in [100, 400, 500, 1000]:
ainfo = sharp.alm_info(lmax)
alms = hp.synalm(np.ones(lmax + 1), lmax=lmax)
alms0 = curvedsky.almxfl(alms.copy(), lambda x: np.ones(x.shape))
assert np.all(np.isclose(alms0, alms))
def test_sharp_alm2map_der1(self):
# Test the wrapper around libsharps alm2map_der1.
lmax = 3
ainfo = sharp.alm_info(lmax)
nrings = lmax + 1
nphi = 2 * lmax + 1
minfo = sharp.map_info_gauss_legendre(nrings, nphi)
sht = sharp.sht(minfo, ainfo)
# Test different input shapes and dtypes.
# Case 1a: 1d double precision.
alm = np.zeros((ainfo.nelem), dtype=np.complex128)
alm[4] = 1. + 1.j
omap = sht.alm2map_der1(alm)
# Compare to expected value by doing spin 1 transform
# on sqrt(ell (ell + 1)) alm.
alm_spin = np.zeros((2, ainfo.nelem), dtype=np.complex128)
alm_spin[0] = alm * np.sqrt(2)
omap_exp = sht.alm2map(alm_spin, spin=1)
np.testing.assert_array_almost_equal(omap, omap_exp)
# Case 1b: 1d single precision.
alm = np.zeros((ainfo.nelem), dtype=np.complex64)
alm[4] = 1. + 1.j
omap = sht.alm2map_der1(alm)
# Compare to expected value by doing spin 1 transform
# on sqrt(ell (ell + 1)) alm.
alm_spin = np.zeros((2, ainfo.nelem), dtype=np.complex64)
alm_spin[0] = alm * np.sqrt(2)
omap_exp = sht.alm2map(alm_spin, spin=1)
np.testing.assert_array_almost_equal(omap, omap_exp)
# Case 2a: 2d double precision.
ntrans = 3
alm = np.zeros((ntrans, ainfo.nelem), dtype=np.complex128)
alm[0, 4] = 1. + 1.j
alm[1, 4] = 2. + 2.j
alm[2, 4] = 3. + 3.j
omap = sht.alm2map_der1(alm)
# Compare to expected value by doing spin 1 transform
# on sqrt(ell (ell + 1)) alm.
alm_spin = np.zeros((ntrans, 2, ainfo.nelem), dtype=np.complex128)
alm_spin[0, 0] = alm[0] * np.sqrt(2)
alm_spin[1, 0] = alm[1] * np.sqrt(2)
alm_spin[2, 0] = alm[2] * np.sqrt(2)
omap_exp = sht.alm2map(alm_spin, spin=1)
np.testing.assert_array_almost_equal(omap, omap_exp)
# Case 2b: 2d single precision.
ntrans = 3
alm = np.zeros((ntrans, ainfo.nelem), dtype=np.complex64)
alm[0, 4] = 1. + 1.j
alm[1, 4] = 2. + 2.j
alm[2, 4] = 3. + 3.j
omap = sht.alm2map_der1(alm)
# Compare to expected value by doing spin 1 transform
# on sqrt(ell (ell + 1)) alm.
alm_spin = np.zeros((ntrans, 2, ainfo.nelem), dtype=np.complex64)
alm_spin[0, 0] = alm[0] * np.sqrt(2)
alm_spin[1, 0] = alm[1] * np.sqrt(2)
alm_spin[2, 0] = alm[2] * np.sqrt(2)
omap_exp = sht.alm2map(alm_spin, spin=1)
np.testing.assert_array_almost_equal(omap, omap_exp)
def test_sharp_alm2map_roundtrip(self):
# Test the wrapper around libsharps alm2map/map2alm.
lmax = 3
ainfo = sharp.alm_info(lmax)
nrings = lmax + 1
nphi = 2 * lmax + 1
minfo = sharp.map_info_gauss_legendre(nrings, nphi)
sht = sharp.sht(minfo, ainfo)
# Test different input shapes and dtypes.
# Case 1a: 1d double precision.
spin = 0
alm = np.zeros((ainfo.nelem), dtype=np.complex128)
alm[4] = 1. + 1.j
omap = sht.alm2map(alm, spin=spin)
self.assertEqual(omap.shape, (minfo.npix, ))
self.assertEqual(omap.dtype, np.float64)
alm_out = sht.map2alm(omap, spin=spin)
np.testing.assert_array_almost_equal(alm_out, alm)
# Case 1b: 1d single precision.
spin = 0
alm = np.zeros((ainfo.nelem), dtype=np.complex64)
alm[4] = 1. + 1.j
omap = sht.alm2map(alm, spin=spin)
self.assertEqual(omap.shape, (minfo.npix, ))
self.assertEqual(omap.dtype, np.float32)
alm_out = sht.map2alm(omap, spin=spin)
np.testing.assert_array_almost_equal(alm_out, alm)
# Case 2a: 2d double precision.
spin = 1
nspin = 2
alm = np.zeros((nspin, ainfo.nelem), dtype=np.complex128)
alm[0, 4] = 1. + 1.j
alm[1, 4] = 2. - 2.j
omap = sht.alm2map(alm, spin=spin)
self.assertEqual(omap.shape, (nspin, minfo.npix))
self.assertEqual(omap.dtype, np.float64)
alm_out = sht.map2alm(omap, spin=spin)
np.testing.assert_array_almost_equal(alm_out, alm)
# Case 2b: 2d single precision.
spin = 1
nspin = 2
alm = np.zeros((nspin, ainfo.nelem), dtype=np.complex64)
alm[0, 4] = 1. + 1.j
alm[1, 4] = 2. - 2.j
omap = sht.alm2map(alm, spin=spin)
self.assertEqual(omap.shape, (nspin, minfo.npix))
self.assertEqual(omap.dtype, np.float32)
alm_out = sht.map2alm(omap, spin=spin)
np.testing.assert_array_almost_equal(alm_out, alm)
# Case 3a: 3d double precision.
spin = 1
nspin = 2
ntrans = 3
alm = np.zeros((ntrans, nspin, ainfo.nelem), dtype=np.complex128)
alm[0, 0, 4] = 1. + 1.j
alm[0, 1, 4] = 2. - 2.j
alm[1, 0, 4] = 3. + 3.j
alm[1, 1, 4] = 4. - 4.j
alm[2, 0, 4] = 5. + 5.j
alm[2, 1, 4] = 6. - 6.j
omap = sht.alm2map(alm, spin=spin)
self.assertEqual(omap.shape, (ntrans, nspin, minfo.npix))
self.assertEqual(omap.dtype, np.float64)
alm_out = sht.map2alm(omap, spin=spin)
np.testing.assert_array_almost_equal(alm_out, alm)
# Case 3b: 3d single precision.
spin = 1
nspin = 2
ntrans = 3
alm = np.zeros((ntrans, nspin, ainfo.nelem), dtype=np.complex64)
alm[0, 0, 4] = 1. + 1.j
alm[0, 1, 4] = 2. - 2.j
alm[1, 0, 4] = 3. + 3.j
alm[1, 1, 4] = 4. - 4.j
alm[2, 0, 4] = 5. + 5.j
alm[2, 1, 4] = 6. - 6.j
omap = sht.alm2map(alm, spin=spin)
self.assertEqual(omap.shape, (ntrans, nspin, minfo.npix))
self.assertEqual(omap.dtype, np.float32)
alm_out = sht.map2alm(omap, spin=spin)
np.testing.assert_array_almost_equal(alm_out, alm)
def test_prepare_alm_mmax(self):
# Check if mmax is correctly handled by prepare_alm.
# Create lmax=mmax=3 alm array and corresponding alm_info.
lmax = 3
nalm = 10 # Triangular alm array of lmax=3 has 10 elements.
alm_in = np.arange(nalm, dtype=np.complex128)
ainfo_in = sharp.alm_info(lmax=3,
mmax=3,
nalm=nalm,
stride=1,
layout="triangular")
# Case 1: provide only alm.
alm_out, ainfo_out = curvedsky.prepare_alm(alm=alm_in, ainfo=None)
np.testing.assert_array_almost_equal(alm_out, alm_in)
self.assertIs(ainfo_out.lmax, ainfo_in.lmax)
self.assertIs(ainfo_out.mmax, ainfo_in.mmax)
self.assertIs(ainfo_out.nelem, ainfo_in.nelem)
# Case 2: provide only alm_info.
alm_out, ainfo_out = curvedsky.prepare_alm(alm=None, ainfo=ainfo_in)
# Expect zero array.
np.testing.assert_array_almost_equal(alm_out, alm_in * 0)
self.assertIs(ainfo_out.lmax, ainfo_in.lmax)
self.assertIs(ainfo_out.mmax, ainfo_in.mmax)
self.assertIs(ainfo_out.nelem, ainfo_in.nelem)
# Case 3: provide alm and alm_info
alm_out, ainfo_out = curvedsky.prepare_alm(alm=alm_in, ainfo=ainfo_in)
np.testing.assert_array_almost_equal(alm_out, alm_in)
self.assertIs(ainfo_out.lmax, ainfo_in.lmax)
self.assertIs(ainfo_out.mmax, ainfo_in.mmax)
self.assertIs(ainfo_out.nelem, ainfo_in.nelem)
# Case 4: provide only alm with lmax=3 and mmax=1.
# This should currently fail.
nalm = 7
alm_in = np.arange(7, dtype=np.complex128)
self.assertRaises(AssertionError, curvedsky.prepare_alm,
**dict(alm=alm_in, ainfo=None, lmax=lmax))
# Case 5: provide only alm_info with lmax=3 and mmax=1.
nalm = 7
ainfo_in = sharp.alm_info(lmax=3,
mmax=1,
nalm=nalm,
stride=1,
layout="triangular")
alm_exp = np.zeros(7, dtype=np.complex128)
alm_out, ainfo_out = curvedsky.prepare_alm(alm=None, ainfo=ainfo_in)
np.testing.assert_array_almost_equal(alm_out, alm_exp)
self.assertIs(ainfo_out.lmax, ainfo_in.lmax)
self.assertIs(ainfo_out.mmax, ainfo_in.mmax)
self.assertIs(ainfo_out.nelem, ainfo_in.nelem)
# Case 6: provide both alm and alm_info with lmax=3 and mmax=1.
# This should be allowed.
nalm = 7
ainfo_in = sharp.alm_info(lmax=3,
mmax=1,
nalm=nalm,
stride=1,
layout="triangular")
alm_in = np.arange(7, dtype=np.complex128)
alm_out, ainfo_out = curvedsky.prepare_alm(alm=alm_in, ainfo=ainfo_in)
np.testing.assert_array_almost_equal(alm_out, alm_in)
self.assertIs(ainfo_out.lmax, ainfo_in.lmax)
self.assertIs(ainfo_out.mmax, ainfo_in.mmax)
self.assertIs(ainfo_out.nelem, ainfo_in.nelem)
def apply_beam_sht(map, bl, tol=1e-5):
lmax = np.where(bl / np.max(bl) > tol)[0][-1]
ainfo = sharp.alm_info(lmax)
alm = curvedsky.map2alm_cyl(map, ainfo=ainfo)
ainfo.lmul(alm, bl[:lmax + 1], out=alm)
return curvedsky.alm2map_cyl(alm, map, copy=True)
kappa_alms = healpy.sphtfunc.map2alm(kappa_map_hp)
shape, wcs = enmap.fullsky_geometry(p['PIX_SIZE_ARCMIN']*utils.arcmin)
# phi_alms = healpy.sphtfunc.almxfl(kappa_alms, 1. / (ells * (ells + 1) / 2.))
# phi_map =
kappa_map_car = enmap.enmap(np.zeros(shape), wcs)
curvedsky.alm2map(kappa_alms, kappa_map_car)
lmax = healpy.Alm.getlmax(len(kappa_alms))
ainfo = sharp.alm_info(lmax)
ellvals = np.arange(lmax)
#factor to change kappa into phi
func = 2. / (ellvals * (ellvals + 1.))
func[0] = 0
phi_alm = healpy.sphtfunc.almxfl(kappa_alms, func)
cmb_powers = get_cmb_powerspectra.websky_cmb_spectra()['unlensed_scalar']
cmb_alm, cmb_ainfo = curvedsky.rand_alm(cmb_powers, lmax = lmax, seed = 1, return_ainfo = True)
unlensed_map, lensed_map = lensing.lens_map_curved((3,) + shape, wcs, phi_alm, cmb_alm, ainfo, output = 'ul')
