def generate_noise_alms(nl_array_t, nl_array_pol, lmax, n_splits):
"""This function generates the alms corresponding to the noise power spectra matrices
nl_array_t, nl_array_pol. The function returns a dictionnary nlms["T", i].
The entry of the dictionnary are for example nlms["T", i] where i is the index of the split.
note that nlms["T", i] is a (nfreqs, size(alm)) array, it is the harmonic transform of
the noise realisation for the different frequencies.
Parameters
----------
nl_array_t : 3d array [nfreq, nfreq, lmax]
noise power spectra matrix for temperature data
nl_array_pol : 3d array [nfreq, nfreq, lmax]
noise power spectra matrix for polarisation data
lmax : integer
the maximum multipole for the noise power spectra
n_splits: integer
the number of data splits we want to simulate
"""
nlms = {}
for k in range(n_splits):
nlms["T", k] = curvedsky.rand_alm(nl_array_t, lmax=lmax)
nlms["E", k] = curvedsky.rand_alm(nl_array_pol, lmax=lmax)
nlms["B", k] = curvedsky.rand_alm(nl_array_pol, lmax=lmax)
return nlms
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 generate_noise_alms(Nl_array_T, Nl_array_P, lmax, nSplits, ncomp):
nlms = {}
if ncomp == 1:
for k in range(nSplits):
nlms[k] = curvedsky.rand_alm(Nl_array_T, lmax=lmax)
else:
for k in range(nSplits):
nlms['T', k] = curvedsky.rand_alm(Nl_array_T, lmax=lmax)
nlms['E', k] = curvedsky.rand_alm(Nl_array_P, lmax=lmax)
nlms['B', k] = curvedsky.rand_alm(Nl_array_P, lmax=lmax)
return nlms
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 generate_noise_alms(nl_array_t,
lmax,
n_splits,
ncomp,
nl_array_pol=None,
dtype=np.complex128):
"""This function generates the alms corresponding to the noise power spectra matrices
nl_array_t, nl_array_pol. The function returns a dictionnary nlms["T", i].
The entry of the dictionnary are for example nlms["T", i] where i is the index of the split.
note that nlms["T", i] is a (narrays, size(alm)) array, it is the harmonic transform of
the noise realisation for the different frequencies.
Parameters
----------
nl_array_t : 3d array [narrays, narrays, lmax]
noise power spectra matrix for temperature data
lmax : integer
the maximum multipole for the noise power spectra
n_splits: integer
the number of data splits we want to simulate
ncomp: interger
the number of components
ncomp = 3 if T,Q,U
ncomp = 1 if T only
nl_array_pol : 3d array [narrays, narrays, lmax]
noise power spectra matrix for polarisation data
(in use if ncomp==3)
"""
nlms = {}
if ncomp == 1:
for k in range(n_splits):
nlms[k] = curvedsky.rand_alm(nl_array_t, lmax=lmax, dtype=dtype)
else:
for k in range(n_splits):
nlms["T", k] = curvedsky.rand_alm(nl_array_t,
lmax=lmax,
dtype=dtype)
nlms["E", k] = curvedsky.rand_alm(nl_array_pol,
lmax=lmax,
dtype=dtype)
nlms["B", k] = curvedsky.rand_alm(nl_array_pol,
lmax=lmax,
dtype=dtype)
return nlms
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_rand_alm(self):
def nalm(lmax):
return (lmax + 1) * (lmax + 2) / 2
lmaxes = [50, 100, 150, 300]
mypower = np.ones(50)
for lmax in lmaxes:
palm = curvedsky.rand_alm(mypower, lmax = lmax)
halm = curvedsky.rand_alm_healpy( mypower, lmax = lmax)
print("nalm(%i) = %i, curvedsky.rand_alm gives %s, curvedsky.rand_alm_healpy gives %s "\
% (lmax, \
nalm(lmax),\
palm.shape, \
halm.shape) )
assert np.all(np.isclose(np.asarray(palm.shape),np.asarray(halm.shape)))
def update_signal_index(self,sim_idx,set_idx=0,cmb_type='LensedUnabberatedCMB'):
signal_path = sints.dconfig['actsims']['signal_path']
cmb_file = os.path.join(signal_path, 'fullsky%s_alm_set%02d_%05d.fits' %(cmb_type, set_idx, sim_idx))
self.alms['cmb'] = hp.fitsfunc.read_alm(cmb_file, hdu = (1,2,3))
comptony_seed = seed_tracker.get_fg_seed(set_idx, sim_idx, 'comptony')
fgres_seed = seed_tracker.get_fg_seed(set_idx, sim_idx, 'srcfree')
#self.alms['comptony'] = curvedsky.rand_alm_healpy(self.cyy, seed = comptony_seed)
self.alms['comptony'] = curvedsky.rand_alm(self.cyy, lmax=self.ellmax, seed = comptony_seed) #!!!!
#self.alms['comptony'] = curvedsky.rand_alm(self.cyy, lmax=self.ellmax, seed = 1) #!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if self.cfgres is not None:
self.alms['fgres'] = curvedsky.rand_alm_healpy(self.cfgres, seed = fgres_seed) # SWITCHED BACK!!!
#self.alms['fgres'] = curvedsky.rand_alm(self.cfgres, lmax=self.ellmax, seed = fgres_seed)
# 1. convert to maximum ellmax
lmax = max([hp.Alm.getlmax(self.alms[comp].shape[1]) for comp in self.alms.keys()])
for comp in self.alms.keys():
if hp.Alm.getlmax(self.alms[comp].shape[1])!=lmax: self.alms[comp] = maps.change_alm_lmax(self.alms[comp], lmax)
self.lmax = lmax
def get_input(input_name,set_idx,sim_idx,shape,wcs):
if input_name=='CMB':
cmb_type = 'LensedUnabberatedCMB'
signal_path = sints.dconfig['actsims']['signal_path']
cmb_file = os.path.join(signal_path, 'fullsky%s_alm_set%02d_%05d.fits' %(cmb_type, set_idx, sim_idx))
alms = hp.fitsfunc.read_alm(cmb_file, hdu = 1)
elif input_name=='tSZ':
ellmax = 8101
ells = np.arange(ellmax)
cyy = fgs.power_y(ells)[None,None]
cyy[0,0][ells<2] = 0
comptony_seed = seed_tracker.get_fg_seed(set_idx, sim_idx, 'comptony')
alms = curvedsky.rand_alm(cyy, seed = comptony_seed,lmax=ellmax)
elif input_name=='kappa':
signal_path = sints.dconfig['actsims']['signal_path']
k_file = os.path.join(signal_path, 'fullskyPhi_alm_%05d.fits' %(sim_idx))
palms = hp.fitsfunc.read_alm(k_file)
from pixell import lensing as plensing
alms = plensing.phi_to_kappa(palms)
omap = enmap.zeros((1,)+shape[-2:],wcs)
omap = curvedsky.alm2map(np.complex128(alms),omap,spin=0)[0]
return omap
def getActpolCmbFgSim(beamfileDict,
shape, wcs,
iterationNum, cmbDir, freqs, psa,
cmbSet = 0, \
doBeam = True, applyWindow = True, verbose = True, cmbMaptype = 'LensedCMB',
foregroundSeed = 0, simType = 'cmb', foregroundPowerFile = None, applyModulation = True):
nTQUs = len('TQU')
firstTime = True
output = enmap.empty((
len(freqs),
nTQUs,
) + shape[-2:], wcs)
if simType == 'cmb':
filename = cmbDir + "/fullsky%s_alm_set%02d_%05d.fits" % (
cmbMaptype, cmbSet, iterationNum)
if verbose:
print('getActpolCmbFgSim(): loading CMB a_lms from %s' % filename)
import healpy
almTebFullskyOnecopy = np.complex128(
healpy.fitsfunc.read_alm(filename, hdu=(1, 2, 3)))
#Now tile the same for all the frequencies requested (i.e. CMB is same at all frequencies).
#The beam convolution happens below.
almTebFullsky = np.tile(almTebFullskyOnecopy, (len(freqs), 1, 1))
if verbose:
print('getActpolCmbFgSim(): done')
elif simType == 'foregrounds':
outputFreqs = ['f090', 'f150']
foregroundPowers \
= powspec.read_spectrum(os.path.join(os.path.dirname(os.path.abspath(__file__)),
'../data/',
foregroundPowerFile),
ncol = 3,
expand = 'row')
if verbose:
print('getActpolCmbFgSim(): getting foreground a_lms')
almTFullsky90and150 = curvedsky.rand_alm(foregroundPowers,
seed=foregroundSeed)
almTebFullsky = np.zeros((
len(freqs),
nTQUs,
) + (len(almTFullsky90and150[-1]), ),
dtype=np.complex128)
for fi, freq in enumerate(freqs):
if freq in outputFreqs:
almTebFullsky[fi, 'TQU'.index('T'), :] \
= almTFullsky90and150[outputFreqs.index(freq), :]
#Convolve with beam on full sky
for fi, freq in enumerate(freqs):
if doBeam:
beamFile = beamfileDict[psa + '_' + freq]
if verbose:
print('getActpolCmbFgSim(): applying beam from %s' % beamFile)
beamData = (np.loadtxt(beamFile))[:, 1]
else:
if verbose:
print('getActpolCmbFgSim(): not convolving with beam')
beamData = np.repeat(1., almTebFullsky.shape[-1])
import healpy
#couldn't quickly figure out how to vectorize this so loop from 0 to 2.
for tqui in range(nTQUs):
almTebFullsky[fi, tqui] = healpy.sphtfunc.almxfl(
almTebFullsky[fi, tqui].copy(), beamData)
#These lines stolen from curvedsky.rand_map
#doing all freqs at once gives error:
#sharp.pyx in sharp.execute_dp (cython/sharp.c:12118)()
#ValueError: ndarray is not C-contiguous
#so loop over all freqs once for now.
curvedsky.alm2map(almTebFullsky, output, spin=[0, 2], verbose=True)
# outputThisfreq = enmap.empty(( nTQUs,)+shape[-2:], wcs)
# curvedsky.alm2map(almTebFullsky[fi,:,:], outputThisfreq, spin = [0,2], verbose = True)
# output[fi,...] = outputThisfreq
# curvedsky.alm2map(almTebFullsky[fi,:,:], output[fi,:,:,:], spin = [0,2], verbose = True)
if applyModulation:
from pixell import aberration
for fi, freq in enumerate(freqs):
print('applying modulation for frequency %s' % freq)
output, A = aberration.boost_map(output,
aberration.dir_equ,
aberration.beta,
return_modulation=True,
aberrate=False,
freq=freqStrToValGhz[freq] * 1e9)
if applyWindow:
from pixell import fft
#The axes along which to FFT
axes = [-2, -1]
if verbose:
print('getActpolCmbFgSim(): applying pixel window function')
nfreq = len(freqs)
for idx in range(nfreq):
fd = fft.fft(output[idx], axes=axes)
wy, wx = enmap.calc_window(fd.shape)
twoDWindow = wy[:, None]**1 * wx[None, :]**1
#Careful, this is quietly multiplying an array with shape [N_freq, N_TQU, N_y, N_x] with one of shape [N_y, N_x]
fd *= twoDWindow
output[idx] = (fft.ifft(fd, axes=axes, normalize=True)).real
del fd
if verbose:
print('getActpolCmbFgSim(): done')
return enmap.ndmap(output, wcs)
def _generate_unlensed_cmb_alm(self, seed=None):
seed = seed if seed is None else np.random.seed(seed_tracker.get_cmb_seed(seed))
lmax = 10000
ualm = curvedsky.rand_alm(self.cmb_spec[0], lmax=lmax, seed=seed)
return ualm
pixwin = hp.pixwin(nside)
bestfit = np.load("%s/bestfit_matrix.npy" % bestfit_dir)
l, nl_array_t, nl_array_pol = planck_utils.noise_matrix(
noise_model_dir, exp, freqs, lmax, nsplits)
so_mpi.init(True)
subtasks = so_mpi.taskrange(imin=d["iStart"], imax=d["iStop"])
for iii in subtasks:
t0 = time.time()
alms = {}
sim_alm = curvedsky.rand_alm(bestfit, lmax=lmax)
if use_ffp10 == False:
nlms = planck_utils.generate_noise_alms(nl_array_t, nl_array_pol, lmax,
nsplits)
for f_id, freq in enumerate(freqs):
maps = d["map_%s" % freq] # In use for the missing pixels
freq_alm = np.zeros((3, sim_alm.shape[1]), dtype="complex")
freq_alm[0] = sim_alm[0 + f_id * 3].copy()
freq_alm[1] = sim_alm[1 + f_id * 3].copy()
freq_alm[2] = sim_alm[2 + f_id * 3].copy()
for hm, map, k in zip(splits, maps, np.arange(nsplits)):
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')
cmb_alm_lensed = curvedsky.map2alm(lensed_map, ainfo = cmb_ainfo)
healpy.fitsfunc.write_alm(p['outdir'] + 'lensed_alm.fits',
np.complex128(cmb_alm_lensed), overwrite = True)
healpy.fitsfunc.write_alm(p['outdir'] + 'unlensed_alm.fits',
np.complex128(cmb_alm), overwrite = True)
nSplits,
lcut=0,
use_noise_th=use_noise_th)
pixwin = hp.pixwin(nside)
so_mpi.init(True)
subtasks = so_mpi.taskrange(imin=d['iStart'], imax=d['iStop'])
for iii in subtasks:
t0 = time.time()
alms = {}
sim_alm = curvedsky.rand_alm(
ps_th, lmax=lmax - 1
) #the nlms and sim_alm lmax need to be investigated, there is a mismatch of 1 that is not understood at the moment
nlms = planck_utils.generate_noise_alms(Nl_T, Nl_P, lmax, nSplits, ncomp)
for freq_id, freq in enumerate(freqs):
maps = d['map_%s' % freq]
if include_foregrounds == True:
freq_alm = np.zeros((3, sim_alm.shape[1]), dtype='complex')
freq_alm[0] = sim_alm[0 + freq_id * 3].copy()
freq_alm[1] = sim_alm[1 + freq_id * 3].copy()
freq_alm[2] = sim_alm[2 + freq_id * 3].copy()
for hm, map, k in zip(splits, maps, np.arange(nSplits)):
scenarios = ["standard", "noE", "noB"]
# we will use mpi over the number of simulations
so_mpi.init(True)
subtasks = so_mpi.taskrange(imin=d["iStart"], imax=d["iStop"])
for iii in subtasks:
t0 = time.time()
for scenario in scenarios:
# generate cmb alms and foreground alms
# cmb alms will be of shape (3, lm) 3 standing for T,E,B
# fglms will be of shape (nfreq, lm) and is T only
alms = curvedsky.rand_alm(ps_cmb, lmax=lmax, dtype=sim_alm_dtype)
fglms = curvedsky.rand_alm(ps_fg, lmax=lmax, dtype=sim_alm_dtype)
master_alms = {}
for sv in surveys:
arrays = d["arrays_%s" % sv]
ks_f = d["k_filter_%s" % sv]
for ar_id, ar in enumerate(arrays):
win_T = so_map.read_map(d["window_T_%s_%s" % (sv, ar)])
win_pol = so_map.read_map(d["window_pol_%s_%s" % (sv, ar)])
window_tuple = (win_T, win_pol)
pl._ax.set_xlim(10, 6500)
pl.hline(y=1)
pl.done("/scratch/r/rbond/msyriac/data/depot/tilec/plots/allfits.png")
#sys.exit()
#lsave = 400
#np.savetxt("/scratch/r/rbond/msyriac/data/for_sigurd/bad_matrix.txt",cfgres[:,:,lsave])
# sys.exit()
fgres_seed = 1
print("done with txt")
print(cfgres.dtype)
alms2 = curvedsky.rand_alm(cfgres, lmax=lmax, seed=fgres_seed)
alms1 = curvedsky.rand_alm_healpy(cfgres, seed=fgres_seed)
print("done")
for i in range(narrays):
for j in range(i, narrays):
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_xlabel('l', fontsize=14)
ax.set_ylabel('D', fontsize=14)
ax.set_xscale('linear', nonposx='clip')
ax.set_yscale('log', nonposy='clip')
qid1 = qids[i]
qid2 = qids[j]
all_freqs = [freq for exp in experiments for freq in d["freqs_%s" % exp]]
ncomp = 3
ps_cmb = powspec.read_spectrum(d["clfile"])[:ncomp, :ncomp]
if include_fg == True:
l, ps_fg = maps_to_params_utils.get_foreground_matrix(
fg_dir, fg_components, all_freqs, lmax_simu + 1)
so_mpi.init(True)
subtasks = so_mpi.taskrange(imin=d["iStart"], imax=d["iStop"])
for iii in subtasks:
#First we will generate our simulations and take their harmonics transforms
t0 = time.time()
alms = curvedsky.rand_alm(ps_cmb, lmax=lmax_simu)
if include_fg == True:
fglms = curvedsky.rand_alm(ps_fg, lmax=lmax_simu)
master_alms = {}
fcount = 0
for exp in experiments:
freqs = d["freqs_%s" % exp]
nsplits = d["nsplits_%s" % exp]
if d["pixel_%s" % exp] == "CAR":
template = so_map.car_template(ncomp, d["ra0_%s" % exp],
d["ra1_%s" % exp],
d["dec0_%s" % exp],
def _generate_gaussian_kappa(self, seed=None):
if seed is not None:
np.random.seed(seed_tracker.get_kappa_seed(seed))
clkk = self.clkk_spec[:, 1]
alm = curvedsky.rand_alm(clkk)
return curvedsky.alm2map(alm, self.template.copy())[np.newaxis, ...]
