def test_precomputed_alms(setup):
alms, filename = setup
nside = 64
# we assume the original `alms` are in `K_CMB`
ref_freq = 40
test_map_K_CMB = hp.alm2map(alms, nside=nside)
alms_K_RJ = alms * pysm.convert_units("K_CMB", "K_RJ", ref_freq)
filename_K_RJ = filename.replace(".fits", "_RJ.fits")
hp.write_alm(filename_K_RJ, alms_K_RJ)
precomputed_alms = PrecomputedAlms(
filename=filename_K_RJ,
nside=nside,
input_units="uK_RJ",
input_reference_frequency_GHz=ref_freq,
)
m = precomputed_alms.signal(23)
np.testing.assert_allclose(
m, test_map_K_CMB * pysm.convert_units("uK_CMB", "uK_RJ", 23))
freqs = np.array([1, 10, 100])
m_multifreq = precomputed_alms.signal(freqs)
assert m_multifreq.shape == (3, 3, hp.nside2npix(64))
for freq, m in zip(freqs, m_multifreq):
np.testing.assert_allclose(
m, test_map_K_CMB * pysm.convert_units("uK_CMB", "uK_RJ", freq))
def get_foreground_maps_and_cl(sky_obj,
miscalibration_angle,
frequencies2use,
mask,
mask_apo,
wsp,
purify_e,
purify_b,
return_dust=True,
return_synchrotron=True,
return_maps=False):
dust_map_freq = []
sync_map_freq = []
Cl_dust_freq = []
Cl_sync_freq = []
for f in frequencies2use:
if return_dust:
dust_maps_ = sky_obj.sky.dust(f) * \
convert_units('K_RJ', 'K_CMB', f)
dust_maps = lib.map_rotation(dust_maps_, miscalibration_angle)
dust_map_freq.append(dust_maps)
f2_dust = get_field(mask * dust_maps[1, :],
mask * dust_maps[2, :],
mask_apo,
purify_e=purify_e,
purify_b=purify_b)
Cl_dust_freq.append(compute_master(f2_dust, f2_dust, wsp))
if return_synchrotron:
sync_maps_ = sky_obj.sky.synchrotron(f) * \
convert_units('K_RJ', 'K_CMB', f)
sync_maps = lib.map_rotation(sync_maps_, miscalibration_angle)
sync_map_freq.append(sync_maps)
f2_sync = get_field(mask * sync_maps[1, :],
mask * sync_maps[2, :],
mask_apo,
purify_e=purify_e,
purify_b=purify_b)
Cl_sync_freq.append(compute_master(f2_sync, f2_sync, wsp))
if return_dust:
dust_map_freq = np.array(dust_map_freq)
Cl_dust_freq = np.array(Cl_dust_freq)
if return_synchrotron:
sync_map_freq = np.array(sync_map_freq)
Cl_sync_freq = np.array(Cl_sync_freq)
if return_maps:
if return_dust and return_synchrotron:
return Cl_dust_freq, Cl_sync_freq, dust_map_freq, sync_map_freq
elif return_dust:
return Cl_dust_freq, dust_map_freq
elif return_synchrotron:
return Cl_sync_freq, sync_map_freq
else:
return Cl_dust_freq, Cl_sync_freq
def get_freq_maps(self, output=0):
cmb_freq_maps = self.sky.cmb(sky_map.cmb_freq) * \
pysm.convert_units('K_RJ', 'K_CMB', sky_map.cmb_freq)
dust_freq_maps = self.sky.dust(sky_map.dust_freq) * \
pysm.convert_units('K_RJ', 'K_CMB', sky_map.dust_freq)
sync_freq_maps = self.sky.synchrotron(sky_map.synchrotron_freq) *\
pysm.convert_units('K_RJ', 'K_CMB', sky_map.synchrotron_freq)
self.cmb_freq_maps = cmb_freq_maps
self.dust_freq_maps = dust_freq_maps
self.sync_freq_maps = sync_freq_maps
del self.sky
if output:
return cmb_freq_maps, dust_freq_maps, sync_freq_maps
def signal(self, nu, **kwargs):
"""Return map in uK_RJ at given frequency or array of frequencies"""
if np.isscalar(nu):
nu = np.array([nu])
filename = utils.get_data_from_url(self.get_filename())
m = pysm.read_map(
filename,
nside=self.nside,
field=0,
pixel_indices=self.pixel_indices,
mpi_comm=self.mpi_comm,
)
npix = (len(self.pixel_indices) if self.pixel_indices is not None else
hp.nside2npix(self.nside))
all_maps = np.zeros((len(nu), 1, npix), dtype=np.double)
szfac = np.ones(len(nu))
if self.sz_type == "thermal":
szfac = y2uK_CMB(nu)
all_maps[:, 0, :] = np.outer(
pysm.convert_units("uK_CMB", "uK_RJ", nu) * szfac, m)
# the output of out is always 3D, (num_freqs, IQU, npix), if num_freqs is one
# we return only a 2D array.
if len(all_maps) == 1:
return all_maps[0]
else:
return all_maps
def main(fname_config):
#Read configuration into classes
Config = ConfigParser.ConfigParser()
Config.read(fname_config)
out = output(Config._sections['GlobalParameters'])
Config.read('./ConfigFiles/'+Config.get('FreeFree','model')+'_config.ini')
freefree = component(Config._sections['FreeFree'],out.nside)
with open(out.output_dir+out.output_prefix+'freefree_config.ini','w') as configfile\
: Config.write(configfile)
print('Computing free-free maps.')
print '----------------------------------------------------- \n'
if out.debug == True:
print ''.join("%s: %s \n" % item for item in vars(freefree).items())
print '----------------------------------------------------- \n'
conv_I = convert_units(freefree.template_units,out.output_units,out.output_frequency)
scaled_map_ff = scale_freqs(freefree,out)*conv_I[...,np.newaxis]*freefree.em_template
scaled_map_ff_pol = np.zeros((2,np.asarray(out.output_frequency).size,hp.nside2npix(out.nside)))
if out.debug == True:
ff = np.concatenate([scaled_map_ff[np.newaxis,...],scaled_map_ff_pol])
for i in range(0,len(out.output_frequency)):
hp.write_map(out.output_dir+out.output_prefix+'ff_%d'%(out.output_frequency[i])+'_'+str(out.nside)+'.fits',ff[:,i,:],coord='G',column_units=out.output_units)
return np.concatenate([scaled_map_ff[np.newaxis,...],scaled_map_ff_pol])
def instrument_noise(fname_config):
Config = ConfigParser.ConfigParser()
Config.read(fname_config)
out = output(Config._sections['GlobalParameters'])
print('Adding instrument noise.')
print '----------------------------------------------------- \n'
npix = hp.nside2npix(out.nside)
#Convert noise to sigma per pixel.
fsky_pix = 1./npix
pix_ster = 4.*np.pi*fsky_pix
pix_amin2 = pix_ster*(180.*60./np.pi)**2 #converts size of pixel from steradians to square arcminutes
sigma_pix_I = np.sqrt(out.instrument_noise_i**2/pix_amin2)
sigma_pix_pol = np.sqrt(out.instrument_noise_pol**2/pix_amin2)
#Generate noise as gaussian with variances above:
np.random.seed(out.instrument_noise_seed)
instrument_noise = np.random.randn(3,np.asarray(out.output_frequency).size,npix)
#standard_normal*sigma+mu = N(mu,sigma)
instrument_noise[0,...]=sigma_pix_I[np.newaxis,:,np.newaxis]*instrument_noise[0,...]
instrument_noise[1,...]=sigma_pix_pol[np.newaxis,:,np.newaxis]*instrument_noise[1,...]
instrument_noise[2,...]=sigma_pix_pol[np.newaxis,:,np.newaxis]*instrument_noise[2,...]
return instrument_noise*convert_units(['u','K_CMB'],out.output_units,out.output_frequency)[np.newaxis,:,np.newaxis]
def read_map(self, freq):
if self.verbose:
print("Reading map {}".format(self.maps[freq]))
m = pysm.read_map(self.maps[freq],
nside=self.nside,
field = (0,1,2) if self.has_polarization else 0,
pixel_indices=self.pixel_indices,
mpi_comm=self.mpi_comm)
return m * pysm.convert_units(self.input_units, "uK_RJ", freq)
def main(fname_config):
#Read in configuration file to classes.
Config = ConfigParser.ConfigParser()
Config.read(fname_config)
out = output(Config._sections['GlobalParameters'])
Config.read('./ConfigFiles/'+Config.get('Synchrotron','model')+'_config.ini')
synch = component(Config._sections['Synchrotron'],out.nside)
with open(out.output_dir+out.output_prefix+'synchrotron_config.ini','w') as configfile: Config.write(configfile)
print('Computing synchrotron maps.')
print '----------------------------------------------------- \n'
if out.debug == True:
print ''.join("%s: %s \n" % item for item in vars(synch).items())
print '----------------------------------------------------- \n'
#The unit conversion takes care of the scaling being done in uK_RJ. After scaling we convert to whatever the output units are.
conv_I = convert_units(synch.template_units, ['u','K_RJ'], synch.freq_ref)
conv_pol = convert_units(synch.template_units, ['u','K_RJ'], synch.pol_freq_ref)
conv2 = convert_units(['u','K_RJ'],out.output_units,out.output_frequency)
unit_conversion_I = conv_I*conv2.reshape((len(out.output_frequency),1))
unit_conversion_pol = conv_pol*conv2.reshape((len(out.output_frequency),1))
#Do the scaling.
scaled_map_synch = scale_freqs(synch, out, pol=False)*synch.em_template*unit_conversion_I
scaled_map_synch_pol = scale_freqs(synch, out, pol=True)[np.newaxis,...]*np.array([synch.polq_em_template,synch.polu_em_template])[:,np.newaxis,:]*unit_conversion_pol
#This section forces P/I<0.75. This is done using the same procedure as the PSM 1.7.8 psm_synchrotron.pro.
P = np.sqrt(scaled_map_synch_pol[0,:,:]**2+scaled_map_synch_pol[1,:,:]**2)/scaled_map_synch
F = 0.75*np.tanh(P/0.75)/P
scaled_map_synch_pol[0,:,:]=F*scaled_map_synch_pol[0,:,:]
scaled_map_synch_pol[1,:,:]=F*scaled_map_synch_pol[1,:,:]
#-------
if out.debug == True:
syn = np.concatenate([scaled_map_synch[np.newaxis,...],scaled_map_synch_pol])
for i in range(0,len(out.output_frequency)):
hp.write_map(out.output_dir+out.output_prefix+'synch_%d'%(out.output_frequency[i])+'_'+str(out.nside)+'.fits',syn[:,i,:],coord='G',column_units=out.output_units)
return np.concatenate([scaled_map_synch[np.newaxis,...],scaled_map_synch_pol])
def test_dependence_on_nu0_CMB(self):
NSIDE = 8
MODEL = 'c1s0'
INSTRUMENT = 'litebird'
sky = pysm.Sky(get_sky(NSIDE, MODEL))
instrument = pysm.Instrument(get_instrument(INSTRUMENT, NSIDE))
components100 = [cm.CMB(), cm.Synchrotron(100.)]
components10 = [cm.CMB(), cm.Synchrotron(10.)]
with suppress_stdout():
freq_maps, _ = instrument.observe(sky, write_outputs=False)
res100 = basic_comp_sep(components100, instrument, freq_maps)
res10 = basic_comp_sep(components10, instrument, freq_maps)
aac(res100.Sigma, res10.Sigma)
aac(res100.x, res10.x)
aac(res100.s[0], res10.s[0])
factor = convert_units('K_CMB', 'K_RJ', 10.)
factor /= convert_units('K_CMB', 'K_RJ', 100.)
aac(res100.s[1], res10.s[1] * 10**res10.x[0] * factor)
def main(fname_config):
#Read in configuration file to classes.
Config = ConfigParser.ConfigParser()
Config.read(fname_config)
out = output(Config._sections['GlobalParameters'])
Config.read('./ConfigFiles/'+Config.get('SpinningDust','model')+'_config.ini')
spdust_general = component(Config._sections['General'],out.nside)
spdust1 = component(Config._sections['SpinningDust1'],out.nside)
spdust2 = component(Config._sections['SpinningDust2'],out.nside)
print('Computing spinning dust map.')
print '----------------------------------------------------- \n'
if out.debug == True:
print ''.join("%s: %s \n" % item for item in vars(spdust1).items())
print ''.join("%s: %s \n" % item for item in vars(spdust2).items())
print '----------------------------------------------------- \n'
with open(out.output_dir+out.output_prefix+'spdust_config.ini','w') as configfile: Config.write(configfile)
#Compute a map of the polarisation angle from the commander dust map polariationn angle.
pol_angle = np.arctan2(spdust_general.thermaldust_polu,spdust_general.thermaldust_polq)
#Units to do the scaling in MJysr and then bring the result back to the output units.
conv1 = convert_units(spdust1.template_units, ['u','K_RJ'], spdust1.freq_ref)
conv2 = convert_units(spdust2.template_units, ['u','K_RJ'], spdust2.freq_ref)
conv_end = convert_units(['u','K_RJ'],out.output_units,out.output_frequency)
unit_conversion1 = conv1*conv_end.reshape((len(out.output_frequency),1))
unit_conversion2 = conv2*conv_end.reshape((len(out.output_frequency),1))
scaled_map_spdust = scale_freqs(spdust1,out,pol=False)*spdust1.em_template*unit_conversion1 + scale_freqs(spdust2,out,pol=False)*spdust2.em_template*unit_conversion2
scaled_map_spdust_pol = scaled_map_spdust[np.newaxis,...]*np.asarray([np.cos(pol_angle),np.sin(pol_angle)])[:,np.newaxis,:]*spdust_general.pol_frac
if out.debug == True:
for i in range(0,len(out.output_frequency)):
hp.write_map(out.output_dir+'spdust_%d.fits'%(out.output_frequency[i]),scaled_map_spdust[i],coord='G',column_units=out.output_units)
return np.concatenate([scaled_map_spdust[np.newaxis,...],scaled_map_spdust_pol])
def scale_dust_pop(pop, out, Config):
dust = component(Config._sections[pop], out.nside)
print ("Computing dust maps.")
print "----------------------------------------------------- \n"
if out.debug == True:
print "".join("%s: %s \n" % item for item in vars(dust).items())
print "----------------------------------------------------- \n"
conv_I = convert_units(dust.template_units, ["u", "K_RJ"], dust.freq_ref)
conv_pol = convert_units(dust.template_units, ["u", "K_RJ"], dust.pol_freq_ref)
conv2 = convert_units(["u", "K_RJ"], out.output_units, out.output_frequency)
unit_conversion_I = conv_I * conv2.reshape((len(out.output_frequency), 1))
unit_conversion_pol = conv_pol * conv2.reshape((len(out.output_frequency), 1))
scaled_map_dust = scale_freqs(dust, out, pol=False) * dust.em_template * unit_conversion_I
scaled_map_dust_pol = (
scale_freqs(dust, out, pol=True)[np.newaxis, ...]
* np.array([dust.polq_em_template, dust.polu_em_template])[:, np.newaxis, :]
* unit_conversion_pol
)
if out.debug == True:
dus = np.concatenate([scaled_map_dust[np.newaxis, ...], scaled_map_dust_pol])
for i in range(0, len(out.output_frequency)):
hp.write_map(
out.output_dir
+ out.output_prefix
+ "dust_%d" % (out.output_frequency[i])
+ "_"
+ str(out.nside)
+ ".fits",
dus[:, i, :],
coord="G",
column_units=out.output_units,
)
return np.concatenate([scaled_map_dust[np.newaxis, ...], scaled_map_dust_pol])
def signal(self):
"""
Simulate CO signal
"""
out = hp.ud_grade(map_in=self.planck_templatemap, nside_out=self.nside)
if self.include_high_galactic_latitude_clouds:
out += self.simulate_high_galactic_latitude_CO()
if self.has_polarization:
Q_map, U_map = self.simulate_polarized_emission(out)
out = np.array([out, Q_map, U_map])
unit_conversion = convert_units("K_CMB", self.output_units,
self.line_frequency)
return out * unit_conversion
def test_precomputed_alms_K_CMB(setup):
alms, filename = setup
nside = 64
test_map = hp.alm2map(alms, nside=nside)
precomputed_alms = PrecomputedAlms(filename=filename,
nside=nside,
input_units="K_CMB")
freqs = np.array([1, 10, 100])
m_multifreq = precomputed_alms.signal(freqs)
assert m_multifreq.shape == (3, 3, hp.nside2npix(64))
for freq, m in zip(freqs, m_multifreq):
np.testing.assert_allclose(
m, test_map * pysm.convert_units("K_CMB", "uK_RJ", freq))
def signal(self, nu=[148.], fwhm_arcmin=None, output_units="uK_RJ", **kwargs):
"""Return map in uK_RJ at given frequency or array of frequencies
If nothing is specified for nu, we default to providing an unmodulated map
at 148 GHz. The value 148 Ghz does not matter if the output is in
uK_RJ.
Parameters
----------
nu : list or ndarray
Frequency or frequencies in GHz at which compute the signal
fwhm_arcmin : float (optional)
Smooth the input alms before computing the signal, this can only be used
if the class was initialized with `precompute_output_map` to False.
output_units : str
Output units, as defined in `pysm.convert_units`, by default this is
"uK_RJ" as expected by PySM.
Returns
-------
output_maps : ndarray
Output maps array with the shape (num_freqs, 1 or 3 (I or IQU), npix)
"""
try:
nnu = len(nu)
except TypeError:
nnu = 1
nu = np.array([nu])
try:
output_map = self.output_map
except AttributeError:
if fwhm_arcmin is None:
alm = self.alm
else:
alm = hp.smoothalm(
self.alm, fwhm=np.radians(fwhm_arcmin / 60), pol=True, inplace=False
)
output_map = self.compute_output_map(alm)
# use tile to output the same map for all frequencies
out = np.tile(output_map, (nnu, 1, 1))
if self.wcs is not None:
out = enmap.enmap(out, self.wcs)
out *= (
(
pysm.convert_units(
self.input_units, "uK_CMB", self.input_reference_frequency_GHz
)
* pysm.convert_units("uK_CMB", output_units, nu)
)
.reshape((nnu, 1, 1))
.astype(float)
)
# the output of out is always 3D, (num_freqs, IQU, npix), if num_freqs is one
# we return only a 2D array.
if len(out) == 1:
return out[0]
else:
return out
