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 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 rand_map(shape, wcs, ps_lensinput, doRotation=False, ps_rot=None, lmax=None,
maplmax=None, dtype=np.float64, seed=None, phi_seed=None,
oversample=2.0, spin=[0,2], output="l", geodesic=True, verbose=False,
delta_theta=None):
from pixell import curvedsky, sharp
ctype = np.result_type(dtype,0j)
# Restrict to target number of components
oshape = shape[-3:]
if len(oshape) == 2: shape = (1,)+tuple(shape)
ncomp = shape[-3]
ps_lensinput = ps_lensinput[:1+ncomp,:1+ncomp]
# First draw a random lensing field, and use it to compute the undeflected positions
if verbose: print("Generating alms")
if phi_seed is None:
alm, ainfo = curvedsky.rand_alm(ps_lensinput, lmax=lmax, seed=seed, dtype=ctype, return_ainfo=True)
else:
# We want separate seeds for cmb and phi. This means we have to do things a bit more manually
wps, ainfo = curvedsky.prepare_ps(ps_lensinput, lmax=lmax)
alm = np.empty([1+ncomp,ainfo.nelem],ctype)
curvedsky.rand_alm_white(ainfo, alm=alm[:1], seed=phi_seed)
curvedsky.rand_alm_white(ainfo, alm=alm[1:], seed=seed)
ps12 = enmap.multi_pow(wps, 0.5)
ainfo.lmul(alm, (ps12/2**0.5).astype(dtype), alm)
alm[:,:ainfo.lmax].imag = 0
alm[:,:ainfo.lmax].real *= 2**0.5
del wps, ps12
phi_alm, cmb_alm = alm[0], alm[1:]
if doRotation:
# generate a gaussian random field of rotational field
alpha_shape = (1, shape[-2], shape[-1])
alpha_map = curvedsky.rand_map(alpha_shape, wcs, ps_rot, lmax=lmax)
# convert alm to enmap object
cmb_map = enmap.empty((3,shape[-2],shape[-1]), wcs)
curvedsky.alm2map(cmb_alm, cmb_map)
# rotate tqu map by a rotational field
# Q_map = cmb_map[1]
# U_map = cmb_map[2]
cmb_map_rot = enmap.rotate_pol(cmb_map, alpha_map)
# convert tqu map back to the alm
cmb_alm = curvedsky.map2alm(cmb_map_rot, lmax=lmax)
del alpha_map, cmb_map, cmb_map_rot
del alm
# Truncate alm if we want a smoother map. In taylens, it was necessary to truncate
# to a lower lmax for the map than for phi, to avoid aliasing. The appropriate lmax
# for the cmb was the one that fits the resolution. FIXME: Can't slice alm this way.
#if maplmax: cmb_alm = cmb_alm[:,:maplmax]
return lens_map_curved(shape=shape, wcs=wcs, phi_alm=phi_alm,
cmb_alm=cmb_alm, phi_ainfo=ainfo, maplmax=maplmax,
dtype=dtype, oversample=oversample, spin=spin,
output=output, geodesic=geodesic, verbose=verbose,
delta_theta=delta_theta)
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 generate_map(shape, wcs, powspec, lmax, seed):
return curvedsky.rand_map(shape,
wcs,
powspec,
lmax=lmax,
dtype=np.float64,
seed=seed,
oversample=2.0,
spin=[0, 2],
method="auto",
direct=False,
verbose=False)
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 generate_sim(ivar_list, cls, lmax, seed):
"""
Input: ivar_list: list of inverse variance maps
cls: flattened 1D power spectrum Pab
lmax:maximum multipole to generate the simulated maps
seed: currently a number, need to fix this.
Returns:
list of sumulated maps.
"""
shape = ivar_list[0].shape
wcs = ivar_list[0].wcs
pmap = enmap.pixsizemap(shape, wcs)
k = len(ivar_list)
sim_maplist = []
for i in range(len(ivar_list)):
sim_map = np.sqrt(k) * cs.rand_map(
shape, wcs, cls, lmax, spin=0, seed=seed + i) / (np.sqrt(
ivar_eff(i, ivar_list) / pmap))
sim_map[~np.isfinite(sim_map)] = 0
sim_maplist.append(sim_map)
return sim_maplist
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:
plot_ps.plot(lmin, lmax, [input_cldd, cl_dd], ['1', '2'])
verbose=True,
phi_seed=phiSeed,
seed=cmbSeed)
mapList = [uTquMap, lTquMap, pMap]
mapNameList = ['fullskyUnlensedCMB', 'fullskyLensedCMB', 'fullskyPhi']
if False:
print(
'temporarily doing a gaussian random field -- lensed = unlensed'
)
print('calling curvedsky.rand_map')
uTquMap = curvedsky.rand_map((3, ) + shape,
wcs,
ps[1:, 1:, :],
lmax=p['LMAX'],
seed=iii * 100)
mapList = [uTquMap]
mapNameList = ['fullskyUnlensed']
if p['doAberration']:
unaberrated = lTquMap.copy()
from pixell import aberration
print('doing aberration')
#This was Sigurd's old version
# lTquMap = aberration.aberrate(lTquMap,
# aberration.dir_equ,
# generate power spectrum for alpha
ell = np.arange(0, lmax + 1)
ps_alpha = A_CB * 1E-4 * 2 * np.pi / (ell * (ell + 1))
ps_alpha[0] = 0
shape, wcs = enmap.fullsky_geometry(pixel_size * utils.arcmin)
for sim_id in np.arange(core_start, core_end):
print("Looking at set=%d sim_id=%d" % (set_id, sim_id))
# check if simulation already exists
postfix = "set%d_id%d.fits" % (set_id, sim_id)
filename = "fullskyalpha_%s" % postfix
filename = os.path.join(alpha_map_dir, filename)
if force or not os.path.isfile(filename):
# generate full sky rotation map
seed = generate_seed(sim_id)
print("Generating random alpha map...")
alpha_map = curvedsky.rand_map((1, ) + shape,
wcs,
ps_alpha,
lmax=lmax,
seed=seed)
# save alpha map
print("Saving to disk...")
print("Saving data: %s..." % filename)
enmap.write_map(filename, alpha_map)
else:
pass