def test_project_nn(self):
shape,wcs = enmap.fullsky_geometry(res=np.deg2rad(12/60.),proj='car')
shape2,wcs2 = enmap.fullsky_geometry(res=np.deg2rad(6/60.),proj='car')
shape3,wcs3 = enmap.fullsky_geometry(res=np.deg2rad(24/60.),proj='car')
imap = enmap.ones(shape,wcs)
omap2 = enmap.project(imap,shape2,wcs2,order=0,mode='wrap')
omap3 = enmap.project(imap,shape3,wcs3,order=0,mode='wrap')
assert np.all(np.isclose(omap2,1))
assert np.all(np.isclose(omap3,1))
def observe(self,freq_GHz,noise_ukarcmin=3.,beam_fwhm_arcmin=8.):
import pysm3
import pysm3.units as u
#np.random.seed(213114124+int(freq_GHz))
beam = gauss_beam(np.arange(self.lmax_sim+10),beam_fwhm_arcmin)#hp.gauss_beam(beam_fwhm_arcmin*(np.pi/60./180),lmax=3*self.nside)
beam[beam==0] = np.inf
beam = 1/beam
shape,wcs = enmap.fullsky_geometry(self.pixRes_arcmin)
Q_noise = np.sqrt(2)*noise_ukarcmin*(np.pi/180/60)*curvedsky.rand_map(shape, wcs, beam**2)
U_noise = np.sqrt(2)*noise_ukarcmin*(np.pi/180/60)*curvedsky.rand_map(shape, wcs, beam**2)
sky = pysm3.Sky(nside=self.nside_pysm,preset_strings=["d1","s1"],output_unit="K_CMB")
# Get the map at the desired frequency:
I,Q_foreground,U_foreground = sky.get_emission(freq_GHz*u.GHz)*1e6
I,Q_foreground,U_foreground = reproject.enmap_from_healpix([I,Q_foreground,U_foreground], shape, wcs,
ncomp=3, unit=1, lmax=self.lmax_sim,rot=None)
Q_map = self.Q_cmb.copy()
Q_map += Q_noise
Q_map += Q_foreground
U_map = self.U_cmb.copy()
U_map += U_noise
U_map += U_foreground
return Q_map,U_map
def __init__(self,camb_file='./CMB_fiducial_totalCls.dat',seed=1,pixRes_arcmin=2.,lmax_sim=500,nside_pysm=512):
cls_camb = np.loadtxt(camb_file,unpack=True)
cl_tt = cls_camb[1]/(cls_camb[0]*(cls_camb[0]+1)/2/np.pi)
cl_tt = np.append([0,0],cl_tt)
cl_ee = cls_camb[2]/(cls_camb[0]*(cls_camb[0]+1)/2/np.pi)
cl_ee = np.append([0,0],cl_ee)
cl_bb = cls_camb[3]/(cls_camb[0]*(cls_camb[0]+1)/2/np.pi)
cl_bb = np.append([0,0],cl_bb)
cl_te = cls_camb[4]/(cls_camb[0]*(cls_camb[0]+1)/2/np.pi)
cl_te = np.append([0,0],cl_te)
ells = np.append([0,1],cls_camb[0])
self.pixRes_arcmin=pixRes_arcmin/180./60*np.pi
self.lmax_sim = lmax_sim
shape,wcs = enmap.fullsky_geometry(self.pixRes_arcmin,dims=(2,))
self.shape = shape
self.wcs = wcs
np.random.seed(seed)
self.nside_pysm =nside_pysm
self.alm_cmb_E = curvedsky.rand_alm(cl_ee,lmax=lmax_sim)#hp.synalm(cl_ee,lmax=3*nside-1,new=True)
self.alm_cmb_B = curvedsky.rand_alm(cl_bb,lmax=lmax_sim)#hp.synalm(cl_bb,lmax=3*nside-1,new=True)
tmp_empty = enmap.empty(shape,wcs)
self.Q_cmb,self.U_cmb = curvedsky.alm2map(np.array([self.alm_cmb_E,self.alm_cmb_B]),tmp_empty,spin=[2])
def observe(self,freq_GHz,noise_ukarcmin=3.,beam_fwhm_arcmin=8.):
#np.random.seed(213114124+int(freq_GHz))
beam = gauss_beam(np.arange(self.lmax_sim+10),beam_fwhm_arcmin)#hp.gauss_beam(beam_fwhm_arcmin*(np.pi/60./180),lmax=3*self.nside)
beam[beam==0] = np.inf
beam = 1/beam
shape,wcs = enmap.fullsky_geometry(self.pixRes_arcmin)
Q_noise = np.sqrt(2)*noise_ukarcmin*(np.pi/180/60)*curvedsky.rand_map(shape, wcs, beam**2)
U_noise = np.sqrt(2)*noise_ukarcmin*(np.pi/180/60)*curvedsky.rand_map(shape, wcs, beam**2)
Q_map = self.Q_cmb.copy()
Q_map += Q_noise
Q_map += self.Q_dust*galaticDust_SED(freq_GHz,in_uk=True)
Q_map += self.Q_sync*synchrotron_SED(freq_GHz,in_uk=True)
U_map = self.U_cmb.copy()
U_map += U_noise
U_map += self.U_dust*galaticDust_SED(freq_GHz,in_uk=True)
U_map += self.U_sync*synchrotron_SED(freq_GHz,in_uk=True)
return Q_map,U_map
def test_area(self):
"""Test that map area is computed accurately."""
test_patches = []
# Small CAR patch
DELT = 0.01
patch = Patch.centered_at(-52., -38., 12. + DELT, 12.0 + DELT)
shape, w = enmap.geometry(pos=patch.pos(),
res=DELT*DEG,
proj='car',
ref=(0, 0))
exact_area = (np.dot(patch.ra_range*DEG, [-1,1]) *
np.dot(np.sin(patch.dec_range*DEG), [1,-1]))
test_patches.append((shape, w, exact_area))
# Full sky CAR patch
shape, w = enmap.fullsky_geometry(res=0.01*DEG, proj='car')
exact_area = 4*np.pi
test_patches.append((shape, w, exact_area))
# Small ZEA patch at pole
shape, w = enmap.geometry(pos=[90*DEG,0], res=DELT*DEG, proj='zea', shape=[100,100])
exact_area = 1*DEG**2
test_patches.append((shape, w, exact_area))
for shape, w, exact_area in test_patches:
ratio = enmap.area(shape, w)/exact_area
print(ratio)
assert(abs(ratio-1) < 1e-6)
def get_lensed_cmb(self, seed=None, kappa=None, save_output=True, verbose=True, overwrite=False, dtype=np.float64):
try:
assert(seed is not None)
assert(not overwrite)
if verbose:
print(f"trying to load saved lensed cmb. sim idx: {seed}")
lmaps = enmap.empty((3,)+self.shape, self.wcs, dtype=dtype)
for i, polidx in enumerate(['T','Q','U']):
fname = self.get_output_file_name("lensed_cmb", seed, polidx=polidx)
lmaps[i] = enmap.read_map(fname)
except:
ualm = self._generate_unlensed_cmb_alm(seed=seed)
if kappa is None:
kappa = self._get_kappa(seed, dtype=np.float64)
lmax = 10000
l = np.arange(lmax+1)
l_fact = 1/((l*(l+1))/2)
l_fact[0] = 0
kalm = curvedsky.map2alm(kappa, lmax=lmax)
kalm = curvedsky.map2alm(kappa, lmax=lmax); del kappa
kalm = hp.almxfl(kalm, l_fact)
tshape, twcs = enmap.fullsky_geometry(res=1*utils.arcmin)
print("start lensing")
lmaps = lensing.lens_map_curved((3,)+tshape, twcs, kalm, ualm)[0]
lalms = curvedsky.map2alm(lmaps, lmax=lmax, spin=0)
lmaps = curvedsky.alm2map(lalms, enmap.zeros((3,)+self.shape, self.wcs), spin=0)
print("finish lensing")
if save_output:
for i, polidx in enumerate(['T','Q','U']):
fname = self.get_output_file_name("lensed_cmb", seed, polidx=polidx)
os.makedirs(os.path.dirname(fname), exist_ok=True)
enmap.write_map(fname, lmaps[i].astype(np.float32))
return lmaps.astype(dtype)
def test_fullsky_geometry(self):
# Tests whether number of pixels and area of a full-sky 0.5 arcminute resolution map are correct
print("Testing full sky geometry...")
test_res_arcmin = 0.5
shape,wcs = enmap.fullsky_geometry(res=np.deg2rad(test_res_arcmin/60.),proj='car')
assert shape[0]==21601 and shape[1]==43200
assert abs(enmap.area(shape,wcs) - 4*np.pi) < 1e-6
def test_pospix(self):
# Posmap separable and non-separable on CAR
for res in [6,12,24]:
shape,wcs = enmap.fullsky_geometry(res=np.deg2rad(res/60.),proj='car')
posmap1 = enmap.posmap(shape,wcs)
posmap2 = enmap.posmap(shape,wcs,separable=True)
assert np.all(np.isclose(posmap1,posmap2))
# Pixmap plain
pres = 0.5
shape,wcs = enmap.geometry(pos=(0,0),shape=(30,30),res=pres*u.degree,proj='plain')
yp,xp = enmap.pixshapemap(shape,wcs)
assert np.all(np.isclose(yp,pres*u.degree))
assert np.all(np.isclose(xp,pres*u.degree))
yp,xp = enmap.pixshape(shape,wcs)
parea = enmap.pixsize(shape,wcs)
assert np.isclose(parea,(pres*u.degree)**2)
assert np.isclose(yp,pres*u.degree)
assert np.isclose(xp,pres*u.degree)
pmap = enmap.pixsizemap(shape,wcs)
assert np.all(np.isclose(pmap,(pres*u.degree)**2))
# Pixmap CAR
pres = 0.1
dec_cut = 89.5 # pixsizemap is not accurate near the poles currently
shape,wcs = enmap.band_geometry(dec_cut=dec_cut*u.degree,res=pres*u.degree,proj='car')
# Current slow and general but inaccurate near the poles implementation
pmap = enmap.pixsizemap(shape,wcs)
# Fast CAR-specific pixsizemap implementation
dra, ddec = wcs.wcs.cdelt*u.degree
dec = enmap.posmap([shape[-2],1],wcs)[0,:,0]
area = np.abs(dra*(np.sin(np.minimum(np.pi/2.,dec+ddec/2))-np.sin(np.maximum(-np.pi/2.,dec-ddec/2))))
Nx = shape[-1]
pmap2 = enmap.ndmap(area[...,None].repeat(Nx,axis=-1),wcs)
assert np.all(np.isclose(pmap,pmap2))
def test_b_sign(self):
"""
We generate a random IQU map with geometry such that cdelt[0]<0
We transform this to TEB with map2harm and map2alm followed by
scalar harm2map and alm2map and use these as reference T,E,B maps.
We flip the original map along the RA direction.
We transform this to TEB with map2harm and map2alm followed by
scalar harm2map and alm2map and use these as comparison T,E,B maps.
We compare these maps.
"""
ells,cltt,clee,clbb,clte = np.loadtxt(DATA_PREFIX+"cosmo2017_10K_acc3_lensedCls.dat",unpack=True)
ps_cmb = np.zeros((3,3,ells.size))
ps_cmb[0,0] = cltt
ps_cmb[1,1] = clee
ps_cmb[2,2] = clbb
ps_cmb[1,0] = clte
ps_cmb[0,1] = clte
np.random.seed(100)
# Curved-sky is fine
lmax = 1000
alm = curvedsky.rand_alm_healpy(ps_cmb,lmax=lmax)
shape,iwcs = enmap.fullsky_geometry(res=np.deg2rad(10./60.))
wcs = enmap.empty(shape,iwcs)[...,::-1].wcs
shape = (3,) + shape
imap = curvedsky.alm2map(alm,enmap.empty(shape,wcs))
oalm = curvedsky.map2alm(imap.copy(),lmax=lmax)
rmap = curvedsky.alm2map(oalm,enmap.empty(shape,wcs),spin=0)
imap2 = imap.copy()[...,::-1]
oalm = curvedsky.map2alm(imap2.copy(),lmax=lmax)
rmap2 = curvedsky.alm2map(oalm,enmap.empty(shape,wcs),spin=0)
assert np.all(np.isclose(rmap[0],rmap2[0]))
assert np.all(np.isclose(rmap[1],rmap2[1]))
assert np.all(np.isclose(rmap[2],rmap2[2]))
# Flat-sky
px = 2.0
N = 300
shape,iwcs = enmap.geometry(pos=(0,0),res=np.deg2rad(px/60.),shape=(300,300))
shape = (3,) + shape
a = enmap.zeros(shape,iwcs)
a = a[...,::-1]
wcs = a.wcs
seed = 100
imap = enmap.rand_map(shape,wcs,ps_cmb,seed=seed)
kmap = enmap.map2harm(imap.copy())
rmap = enmap.harm2map(kmap,spin=0) # reference map
imap = imap[...,::-1]
kmap = enmap.map2harm(imap.copy())
rmap2 = enmap.harm2map(kmap,spin=0)[...,::-1] # comparison map
assert np.all(np.isclose(rmap[0],rmap2[0]))
assert np.all(np.isclose(rmap[1],rmap2[1],atol=1e0))
assert np.all(np.isclose(rmap[2],rmap2[2],atol=1e0))
def get_offset_result(res=1.,dtype=np.float64,seed=1):
shape,wcs = enmap.fullsky_geometry(res=np.deg2rad(res))
shape = (3,) + shape
obs_pos = enmap.posmap(shape, wcs)
np.random.seed(seed)
grad = enmap.enmap(np.random.random(shape),wcs)*1e-3
raw_pos = enmap.samewcs(lensing.offset_by_grad(obs_pos, grad, pol=shape[-3]>1, geodesic=True), obs_pos)
return obs_pos,grad,raw_pos
def test_tilemap(self):
shape, wcs = enmap.fullsky_geometry(30 * utils.degree)
assert shape == (7, 12)
geo = tilemap.geometry((3, ) + shape, wcs, tile_shape=(2, 2))
assert len(geo.active) == 0
assert np.all(geo.lookup < 0)
assert geo.ntile == 24
assert geo.nactive == 0
assert geo.tile_shape == (2, 2)
assert geo.grid_shape == (4, 6)
assert tuple(geo.tile_shapes[0]) == (2, 2)
assert tuple(geo.tile_shapes[5]) == (2, 2)
assert tuple(geo.tile_shapes[18]) == (1, 2)
assert tuple(geo.tile_shapes[23]) == (1, 2)
assert geo.ind2grid(7) == (1, 1)
assert geo.grid2ind(1, 1) == 7
geo = geo.copy(active=[1])
assert geo.nactive == 1
assert np.sum(geo.lookup >= 0) == 1
assert geo.active[0] == 1
assert geo.lookup[1] == 0
geo2 = geo.copy(active=[0, 1, 2])
assert geo.nactive == 1
assert geo2.nactive == 3
assert geo.compatible(geo) == 2
assert geo.compatible(geo2) == 1
geo3 = tilemap.geometry((3, ) + shape, wcs, tile_shape=(2, 3))
assert geo.compatible(geo3) == 0
del geo2, geo3
m1 = tilemap.zeros(geo.copy(active=[1, 2]))
m2 = tilemap.zeros(geo.copy(active=[2, 3, 4]))
m3 = tilemap.zeros(geo.copy(active=[2]))
for a, i in enumerate(m1.geometry.active):
m1.active_tiles[a] = i
for a, i in enumerate(m2.geometry.active):
m2.active_tiles[a] = i * 10
for a, i in enumerate(m3.geometry.active):
m3.active_tiles[a] = i * 100
assert m1[0, 0] == 1
assert np.all(m1.tiles[1] == m1.active_tiles[0])
m12 = m1 + m2
m21 = m2 + m1
assert (m12.nactive == 4)
assert (m21.nactive == 4)
assert (np.all(m12.tiles[1] == 1))
assert (np.all(m21.tiles[1] == 1))
assert (np.all(m12.tiles[2] == 22))
assert (np.all(m21.tiles[2] == 22))
assert (sorted(m12.geometry.active) == sorted(m21.geometry.active))
m1 += m3
assert np.all(m1.tiles[2] == 202)
with self.assertRaises(ValueError):
m3 += m1
m1[:] = 0
m1c = np.cos(m1)
assert m1c.geometry.nactive == 2
assert np.allclose(m1c, 1)
def get_geom(c):
try:
nside = c.nside
shape, wcs = None, None
res = None
except:
nside = None
res = c.res
shape, wcs = enmap.fullsky_geometry(res=np.deg2rad(res / 60.0))
return nside, shape, wcs, res
def get_lens_result(res=1.,lmax=400,dtype=np.float64,seed=1):
shape,wcs = enmap.fullsky_geometry(res=np.deg2rad(res))
shape = (3,) + shape
# ells = np.arange(lmax)
ps_cmb,ps_lens = powspec.read_camb_scalar(DATA_PREFIX+"test_scalCls.dat")
ps_lensinput = np.zeros((4,4,ps_cmb.shape[-1]))
ps_lensinput[0,0] = ps_lens
ps_lensinput[1:,1:] = ps_cmb
lensed = lensing.rand_map(shape, wcs, ps_lensinput, lmax=lmax, maplmax=None, dtype=dtype, seed=seed, phi_seed=None, oversample=2.0, spin=[0,2], output="lu", geodesic=True, verbose=False, delta_theta=None)
return lensed
def test_sim_slice(self):
ps = powspec.read_spectrum(DATA_PREFIX+"test_scalCls.dat")[:1,:1]
test_res_arcmin = 10.0
lmax = 2000
fact = 2.
shape,wcs = enmap.fullsky_geometry(res=np.deg2rad(test_res_arcmin/60.),proj='car')
omap = curvedsky.rand_map(shape, wcs, ps,lmax=lmax)
ofunc = lambda ishape,iwcs: fact*enmap.extract(omap,ishape,iwcs)
nmap = reproject.populate(shape,wcs,ofunc,maxpixy = 400,maxpixx = 400)
assert np.all(np.isclose(nmap/omap,2.))
def test_sim_slice():
path = os.path.dirname(enmap.__file__) + "/../tests/"
ps = powspec.read_spectrum(path + "data/test_scalCls.dat")[:1, :1]
test_res_arcmin = 10.0
lmax = 2000
fact = 2.
shape, wcs = enmap.fullsky_geometry(res=np.deg2rad(test_res_arcmin / 60.),
proj='car')
omap = curvedsky.rand_map(shape, wcs, ps, lmax=lmax)
ofunc = lambda ishape, iwcs: fact * enmap.extract(omap, ishape, iwcs)
nmap = reproject.populate(shape, wcs, ofunc, maxpixy=400, maxpixx=400)
assert np.all(np.isclose(nmap / omap, 2.))
def get_geometries(yml_section):
geos = {}
for g in yml_section:
if g['type'] == 'fullsky':
geos[g['name']] = enmap.fullsky_geometry(res=np.deg2rad(
g['res_arcmin'] / 60.),
proj=g['proj'])
elif g['type'] == 'pickle':
geos[g['name']] = pickle.load(
open(DATA_PREFIX + "%s" % g['filename'], 'rb'))
else:
raise NotImplementedError
return geos
def __init__(self,camb_file='./CMB_fiducial_totalCls.dat',seed=1,pixRes_arcmin=4,lmax_sim=500):
cls_camb = np.loadtxt(camb_file,unpack=True)
cl_tt = cls_camb[1]/(cls_camb[0]*(cls_camb[0]+1)/2/np.pi)
cl_tt = np.append([0,0],cl_tt)
cl_ee = cls_camb[2]/(cls_camb[0]*(cls_camb[0]+1)/2/np.pi)
cl_ee = np.append([0,0],cl_ee)
cl_bb = cls_camb[3]/(cls_camb[0]*(cls_camb[0]+1)/2/np.pi)*0.05
cl_bb = np.append([0,0],cl_bb)
cl_te = cls_camb[4]/(cls_camb[0]*(cls_camb[0]+1)/2/np.pi)
cl_te = np.append([0,0],cl_te)
ells = np.append([0,1],cls_camb[0])
self.pixRes_arcmin=pixRes_arcmin/180./60*np.pi
self.lmax_sim = lmax_sim
shape,wcs = enmap.fullsky_geometry(self.pixRes_arcmin,dims=(2,))
np.random.seed(seed)
self.shape = shape
self.wcs = wcs
self.alm_cmb_E = curvedsky.rand_alm(cl_ee,lmax=lmax_sim)#hp.synalm(cl_ee,lmax=3*nside-1,new=True)
self.alm_cmb_B = curvedsky.rand_alm(cl_bb,lmax=lmax_sim)#hp.synalm(cl_bb,lmax=3*nside-1,new=True)
tmp_empty = enmap.empty(shape,wcs)
self.Q_cmb,self.U_cmb = curvedsky.alm2map(np.array([self.alm_cmb_E,self.alm_cmb_B]),tmp_empty,spin=[2])
ps = np.zeros([2,2,lmax_sim])
ps[0,0] = synchrotron_Cl('E','E')[:lmax_sim]
ps[1,1] = galaticDust_Cl('E','E')[:lmax_sim]
ps[1,0] = syncxdust_Cls('E','E')[:lmax_sim]
self.alm_sync_E,self.alm_dust_E = curvedsky.rand_alm(ps,lmax=lmax_sim)
ps = np.zeros([2,2,lmax_sim])
ps[0,0] = synchrotron_Cl('B','B')[:lmax_sim]
ps[1,1] = galaticDust_Cl('B','B')[:lmax_sim]
ps[1,0] = syncxdust_Cls('B','B')[:lmax_sim]
self.alm_sync_B,self.alm_dust_B = curvedsky.rand_alm(ps,lmax=lmax_sim)
tmp_empty = enmap.empty(shape,wcs)
self.Q_dust,self.U_dust = curvedsky.alm2map(np.array([self.alm_dust_E,self.alm_dust_B]),tmp_empty,spin=[2])
tmp_empty = enmap.empty(shape,wcs)
self.Q_sync,self.U_sync = curvedsky.alm2map(np.array([self.alm_sync_E,self.alm_sync_B]),tmp_empty,spin=[2])
def get_geometries(yml_section):
geos = {}
for g in yml_section:
if g['type'] == 'fullsky':
geos[g['name']] = enmap.fullsky_geometry(res=np.deg2rad(
g['res_arcmin'] / 60.),
proj=g['proj'])
elif g['type'] == 'pickle':
path = os.path.dirname(enmap.__file__) + "/../tests/"
geos[g['name']] = pickle.load(
open(path + "data/%s" % g['filename'], 'rb'))
else:
raise NotImplementedError
return geos
def test_noise_simulator_car(tube):
from pixell import enmap
seed = 1234
shape, wcs = enmap.fullsky_geometry(res=res)
simulator = mapsims.SONoiseSimulator(shape=shape, wcs=wcs)
output_map = simulator.simulate(tube, seed=seed)
expected_map = enmap.read_map(
data.get_pkg_data_filename(
f"data/noise_{tube}_uKCMB_classical_res30_seed1234_car.fits.gz"
)
)
assert_quantity_allclose(output_map, expected_map, rtol=1e-5)
def test_full_sky(self):
"""Test that fullsky_geometry returns sensible objects.
Or at least the objects that we considered sensible when we
wrote this test.
"""
shape, w = enmap.fullsky_geometry(res=0.01*DEG, proj='car')
ny, nx = shape
for delta, expect_nans in [(0., False), (.001, True)]:
for ix in [-0.5-delta,nx-0.5+delta]:
for iy in [0-delta, ny-1+delta]:
c = w.wcs_pix2world([(ix,iy)], 0)
#print(ix,iy,c)
assert np.any(np.isnan(c)) == expect_nans
def get_mv_kappa(polcomb, xalm, yalm):
shape, wcs = enmap.fullsky_geometry(res=np.deg2rad(0.5 * 8192 / nside /
60.))
res = qe.qe_all(shape,
wcs,
lambda x, y: theory.lCl(x, y),
mlmax,
yalm[0],
yalm[1],
yalm[2],
estimators=[polcomb],
xfTalm=xalm[0],
xfEalm=xalm[1],
xfBalm=xalm[2])
return res[polcomb]
def webget(tilepath,
box,
tsize=675,
res=0.5 * utils.arcmin,
dtype=np.float64,
verbose=False):
# Build the geometry representing the tiles web map. This is a normal
# fullsky geometry, except that the origin is in the top-left corner
# instead of the bottom-left, so we flip the y axis.
geo = enmap.Geometry(*enmap.fullsky_geometry(res=res))[::-1]
ntile = np.array(geo.shape) // tsize
pbox = enmap.subinds(*geo, box, cap=False, noflip=True)
# Set up output geometry with the same ordering as the input one. We will
# flip it to the final ordering at the end
ogeo = geo[pbox[0, 0]:pbox[1, 0], pbox[0, 1]:pbox[1, 1]]
omap = enmap.zeros(*ogeo, dtype=dtype)
# Loop through tiles
t1 = pbox[0] // tsize
t2 = (pbox[1] + tsize - 1) // tsize
urls = []
for ty in range(t1[0], t2[0]):
ty = ty % ntile[0]
for tx in range(t1[1], t2[1]):
tx = tx % ntile[1]
url = tilepath.format(y=ty, x=tx)
urls.append(url)
datas = download_all(urls, verbose=verbose)
di = 0
for ty in range(t1[0], t2[0]):
ty = ty % ntile[0]
y1, y2 = ty * tsize, (ty + 1) * tsize
for tx in range(t1[1], t2[1]):
tx = tx % ntile[1]
x1, x2 = tx * tsize, (tx + 1) * tsize
tgeo = geo[y1:y2, x1:x2]
data = datas[di]
di += 1
imgdata = np.array(Image.open(io.BytesIO(data)))
mapdata, mask = unpack(imgdata)
map = enmap.enmap(mapdata, tgeo.wcs)
omap.insert(map)
# Flip omap to normal ordering
omap = omap[::-1]
return omap
modlmap = imap.modlmap()
ells = np.arange(0, 8000, 1)
fcurve = np.exp(-(ells - 4000)**2. / 2. / 200**2.)
return maps.filter_map(imap, maps.interp(ells, fcurve)(modlmap))
#mask = sints.get_act_mr3_crosslinked_mask("deep56")
#dm = sints.ACTmr3(region=mask,pickupsub=False)
# dm = sints.ACTmr3(pickupsub=False)
# imap = enmap.pad(dm.get_coadd("s14","deep56","pa1_f150",srcfree=True,ncomp=None)[0],300)
# shape,wcs = imap.shape,imap.wcs
# shape,wcs = maps.rect_geometry(width_deg=20.,px_res_arcmin=0.5)
# imap = enmap.rand_map(shape,wcs,np.ones((1,1,shape[0],shape[1])))
oshape, owcs = enmap.fullsky_geometry(res=np.deg2rad(0.5 / 60.))
Ny = oshape[-2:][0]
deg = 5
npix = deg / (0.5 / 60.)
shape, wcs = enmap.slice_geometry(
oshape, owcs, np.s_[int(Ny // 2 - npix):int(Ny // 2 + npix), :])
imap = enmap.rand_map(shape, wcs, np.ones((1, 1, shape[0], shape[1])))
ta = tiling.TiledAnalysis(shape, wcs, comm)
ta.initialize_output("out")
for ext, ins in ta.tiles():
emap = ext(imap)
emap = filter_map(emap)
ta.update_output("out", emap, ins)
def test_fullsky_geometry():
# Tests whether number of pixels and area of a full-sky 0.5 arcminute resolution map are correct
test_res_arcmin = 0.5
shape,wcs = enmap.fullsky_geometry(res=np.deg2rad(test_res_arcmin/60.),proj='car')
assert shape[0]==21601 and shape[1]==43200
assert 50000 < (enmap.area(shape,wcs)*(180./np.pi)**2.) < 51000
import plot_ps
from astropy.io import fits
importlib.reload(plot_ps)
lmin = 2
lmax = 1000
ls = np.arange(0, lmax)
nside = 400
def t(ls):
return ls * (ls + 1)
shape, wcs = enmap.fullsky_geometry(res=20 * utils.arcmin, proj='car')
# generate unlensed map using input unlensd ps
unlensed_ps = load_data.unlensed(lmin, lmax, 'TT').spectra()
unlensed_map = curvedsky.rand_map(shape, wcs, unlensed_ps)
unlensed_alm = curvedsky.map2alm(unlensed_map, lmax=lmax)
# generate deflection potential using input
input_cldd = load_data.input_cldd(lmin, lmax).spectra()
if 1:
phi_lm = fitsfunc.read_alm('./fullskyPhi_alm_00000.fits')
phi_lm = phi_lm.astype(np.cdouble)
cl_phi = sphtfunc.alm2cl(a)[0:lmax]
cl_dd = cl_phi * t(ls)
if 1:
"""
# Lensing reconstruction ell range
lmin = 100
lmax = 3000
polcomb = 'TT'
# Number of sims
nsims = 1
# CAR resolution is decided based on lmax
res = np.deg2rad(2.0 * (3000 / lmax) / 60.)
# Make the full sky geometry
shape, wcs = enmap.fullsky_geometry(res=res)
# We use a mask of ones for this test
mask = enmap.ones(shape, wcs)
# Initialize the lens simulation interface
solint = solenspipe.SOLensInterface(mask=mask,
data_mode=None,
scanning_strategy="isotropic",
fsky=0.4)
# Choose the frequency channel
channel = mapsims.SOChannel("LA", 145)
#empty map showing the shape and geometry of the system
omap = enmap.zeros((2, ) + shape[-2:], wcs)
def hdowngrade(imap, shape, wcs, lmax):
return (cs.alm2map(cs.map2alm(imap, lmax=lmax),
enmap.empty(shape, wcs, dtype=imap.dtype)))
i = splitnum
fname = f"/home/r/rbond/sigurdkn/project/actpol/planck/npipe/car_equ/planck_npipe_{freq}_split{i+1}_map.fits"
hlmax = 12000
nside = 2048
llmax = 3 * nside
print("Loading map...")
oimap = enmap.read_map(fname, sel=np.s_[0, ...])
oshape, owcs = enmap.fullsky_geometry(res=2.0 * u.arcmin)
print("Downgrading map...")
imap = hdowngrade(oimap, oshape, owcs, lmax=hlmax)
# %%
ells = np.arange(9000)
theory = cosmology.default_theory()
cltt = theory.lCl('TT', ells)
smap = fit_beam(imap,
np.asarray((decs, ras)).T,
fwhm=4.83,
ps=cltt,
noise=818.2,
r=15 * u.arcmin)
"""
Loads a catalog
Maps it
Smooths it
Thresholds it
Projects it onto ACT
This gives a mask of 1s and 0s from which a random catalog can be made
"""
paths = cutils.paths
#cat_type = "wise_panstarrs"
#cat_type = "madcows_photz"
cat_type = args.sys[1]
meanfield = False
# cat_type = "sdss_redmapper"
# meanfield = True
shape,wcs = enmap.fullsky_geometry(res=1 * utils.degree)
ras,decs,_ = cutils.catalog_interface(cat_type,is_meanfield=meanfield)
cmapper = catalogs.CatMapper(ras,decs,shape=shape,wcs=wcs)
cmap = maps.binary_mask(enmap.smooth_gauss(cmapper.counts,2 * utils.degree),1e-3)
io.hplot(cmap,'counts')
shape,wcs = enmap.read_map_geometry(paths.coadd_data + f"act_planck_s08_s18_cmb_f150_daynight_srcfree_map.fits")
omap = enmap.project(cmap,shape,wcs,order=0)
io.plot_img(omap,'pcounts')
enmap.write_map(f'{paths.scratch}{cat_type}_mask.fits',omap)
from __future__ import print_function
from orphics import maps, io, cosmology, stats
from pixell import enmap
import numpy as np
import os, sys
from actsims import signal
shape, wcs = enmap.fullsky_geometry(res=np.deg2rad(4. / 60.))
cmb_type = 'LensedUnabberatedCMB'
model = 'planck_hybrid'
dobeam = True
apply_window = False
max_cached = 0
s1 = signal.SignalGen(cmb_type=cmb_type,
dobeam=dobeam,
add_foregrounds=True,
apply_window=apply_window,
max_cached=max_cached,
model=model)
# Note freq_idx = 1 for 150 GHz
imap_143 = s1.get_signal_sim('planck',
'planck',
'planck',
'143',
sim_num=0,
save_alm=True,
save_map=False,
set_idx=0,
Nl = maps.interp(ls, nlkks['TT'])(ells)
lpls, lpal = np.loadtxt("data/nls_2000.txt", unpack=True)
pl = io.Plotter(yscale='log', xscale='log')
pl.add(ells, theory.gCl('kk', ells), lw=3, color='k')
pl.add(ells, Nl, ls="--")
pl.add(lpls, lpal * (lpls * (lpls + 1.))**2. / 4., ls="-.")
#pl._ax.set_ylim(1e-10,1e-6)
pl.done(io.dout_dir + "fullsky_qe_result_al.png")
dh_nls = np.nan_to_num(lpal * (lpls * (lpls + 1.))**2. / 4.)
dh_als = np.nan_to_num(dh_nls * 2. / lpls / (lpls + 1))
Al = dh_als
#### MAKE FULL-SKY LENSED SIMS
shape, wcs = enmap.fullsky_geometry(res=np.deg2rad(res / 60.), proj="car")
if not (use_saved):
# Make a full-sky enlib geometry in CAR
pfile = camb_root + "_lenspotentialCls.dat"
ps = powspec.read_camb_full_lens(pfile).astype(dtype)
cache_loc = "/gpfs01/astro/workarea/msyriac/data/depot/falafel/"
try:
assert cache
Xmap = enmap.read_map("%slensed_map_seed_%d.fits" % (cache_loc, seed))
ikappa = enmap.read_map("%skappa_map_seed_%d.fits" % (cache_loc, seed))
print("Loaded cached maps...")
except:
print("Making random lensed map...")
with bench.show("lensing"):
Xmap, ikappa, = enlensing.rand_map(shape[-2:],
wcs,
