def test_dependence_on_nu0_RJ(self):
NSIDE = 8
MODEL = 'c1s0'
INSTRUMENT = 'litebird'
sky = pysm.Sky(get_sky(NSIDE, MODEL))
instrument = pysm.Instrument(
get_instrument(INSTRUMENT, NSIDE, units='uK_RJ'))
components100 = [
cm.CMB(units='K_RJ'),
cm.Synchrotron(100., units='K_RJ')
]
components10 = [
cm.CMB(units='K_RJ'),
cm.Synchrotron(10., units='K_RJ')
]
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])
aac(res100.s[1], res10.s[1] * 10**res10.x[0])
def test_dependence_on_nu0_CMB(self):
NSIDE = 4
MODEL = 'c1s0'
INSTRUMENT = 'LiteBIRD'
sky = get_sky(NSIDE, MODEL)
instrument = get_instrument(INSTRUMENT)
components100 = [cm.CMB(), cm.Synchrotron(100.)]
components10 = [cm.CMB(), cm.Synchrotron(10.)]
freq_maps = get_observation(instrument, sky)
res10 = basic_comp_sep(components10, instrument, freq_maps)
res100 = basic_comp_sep(components100, instrument, freq_maps)
aac(res100.Sigma, res10.Sigma)
aac(res100.x, res10.x)
aac(res100.s[0], res10.s[0], atol=1e-7)
factor = _cmb2rj(10.) * _rj2cmb(100.)
aac(res100.s[1], res10.s[1] * 10**res10.x[0] * factor)
def test_dependence_on_nu0_RJ(self):
NSIDE = 8
MODEL = 'c1s0'
INSTRUMENT = 'LiteBIRD'
sky = get_sky(NSIDE, MODEL)
instrument = get_instrument(INSTRUMENT)
components100 = [
cm.CMB(units='K_RJ'),
cm.Synchrotron(100., units='K_RJ')
]
components10 = [
cm.CMB(units='K_RJ'),
cm.Synchrotron(10., units='K_RJ')
]
freq_maps = get_observation(instrument, sky, unit='K_RJ')
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])
aac(res100.s[1], res10.s[1] * 10**res10.x[0])
def load_foregrounds(self, config):
"""
Loads the foreground models and prepares the unit conversions to K_CMB units.
"""
self.components = {}
for key, component in config['fg_model'].items():
self.components[key] = {}
nu0 = component['parameters']['nu0']
sed_fnc = get_fgbuster_sed(component['sed'])
self.components[key]['sed'] = sed_fnc(**component['parameters'],
units='K_RJ')
self.components[key]['cmb_n0_norm'] = fgc.CMB('K_RJ').eval(
nu0) * nu0**2
self.components[key]['nu0'] = nu0
self.components[key]['spectrum_params'] = component['spectrum']
return
def setUp(self):
NSIDE = 16
MODEL = 'c1d0s0f1'
INSTRUMENT = 'LiteBIRD'
X0_FACTOR = 0.99
sky = get_sky(NSIDE, MODEL)
self.instrument = get_instrument(INSTRUMENT)
self.freq_maps = get_observation(self.instrument, sky)
self.components = [cm.CMB(), cm.Dust(200.), cm.Synchrotron(100.)]
freefree = cm.PowerLaw(100.)
freefree.defaults = [-2.14] # Otherwise it is the same as Synchrotron
self.components.append(freefree)
self.input = []
for component in self.components:
self.input += component.defaults
component.defaults = [d * X0_FACTOR for d in component.defaults]
def setUp(self):
self.DX = 5e-4 # NOTE: this is a bit fine-tuned
np.random.seed(0)
self.n_freq = 6
self.nu = np.logspace(1, 2.5, self.n_freq)
self.n_stokes = 3
self.n_pixels = 2
self.components = [cm.CMB(), cm.Dust(200.), cm.Synchrotron(70.)]
self.mm = MixingMatrix(*(self.components))
self.params = [1.54, 20, -3]
self.A = self.mm.eval(self.nu, *(self.params))
self.A_dB = self.mm.diff(self.nu, *(self.params))
self.A_dBdB = self.mm.diff_diff(self.nu, *(self.params))
self.invN = uniform(size=(self.n_pixels, self.n_stokes, self.n_freq,
self.n_freq))
self.invN += _T(self.invN)
self.invN += 10 * np.eye(self.n_freq)
self.invN *= 10
def setUp(self):
NSIDE = 16
MODEL = 'c1d0s0f1'
INSTRUMENT = 'litebird'
X0_FACTOR = 0.99
sky = pysm.Sky(get_sky(NSIDE, MODEL))
self.instrument = pysm.Instrument(get_instrument(INSTRUMENT, NSIDE))
with suppress_stdout():
self.freq_maps, self.noise = self.instrument.observe(
sky, write_outputs=False)
self.components = [cm.CMB(), cm.Dust(200.), cm.Synchrotron(100.)]
freefree = cm.PowerLaw(100.)
freefree.defaults = [-2.14] # Otherwise it is the same as Synchrotron
self.components.append(freefree)
self.input = []
for component in self.components:
self.input += component.defaults
component.defaults = [d * X0_FACTOR for d in component.defaults]
def load_foregrounds(self, config):
self.component_names = []
self.components = {}
self.component_order = {}
i_comp = 0
for key, component in self.component_iterator(config):
comp = {}
decorr = component.get('decorr')
comp['decorr'] = False
if decorr:
comp['decorr'] = True
comp['decorr_param_names'] = {}
for k, l in decorr.items():
comp['decorr_param_names'][l[0]] = k
comp['names_x_dict'] = {}
d_x = component.get('cross')
if d_x:
for pn, par in d_x.items():
if par[0] not in config['fg_model'].keys():
raise KeyError("Component %s " % (par[0]) +
"is not a valid component" +
"to correlate %s with" % key)
if par[0] == key:
raise KeyError("%s is cross correlated with itself." %
par[0])
comp['names_x_dict'][par[0]] = pn
# Loop through SED parameters.
# Find nu0 if it exists
# Make a list of all parameters ready to pass to fgc
comp['sed_parameters'] = component['sed_parameters']
nu0 = None
params_fgc = {}
comp['names_sed_dict'] = {}
for k, l in comp['sed_parameters'].items():
comp['names_sed_dict'][l[0]] = k
# nu0
if l[0] == 'nu0':
if l[1] != 'fixed':
raise ValueError("You can't vary reference"
" frequencies!")
nu0 = l[2][0]
# SED parameter
if l[1] == 'fixed':
val = l[2][0]
else:
val = None
params_fgc[l[0]] = val
# Set units normalization
if nu0 is not None:
comp['cmb_n0_norm'] = fgc.CMB('K_RJ').eval(nu0)
else:
comp['cmb_n0_norm'] = 1.
# Set SED function
sed_fnc = get_function(fgc, component['sed'])
comp['sed'] = sed_fnc(**params_fgc, units='K_RJ')
# Same thing for C_ell parameters
comp['names_cl_dict'] = {}
params_fgl = {}
for k, d in component['cl_parameters'].items():
p1, p2 = k
# Add parameters only if we're using both polarization channels
if ((p1 in config['pol_channels'])
and (p2 in config['pol_channels'])):
comp['names_cl_dict'][k] = {}
params_fgl[k] = {}
for n, l in d.items():
comp['names_cl_dict'][k][l[0]] = n
if l[0] == 'ell0':
if l[1] != 'fixed':
raise ValueError("You can't vary "
"reference scales!")
if l[1] == 'fixed':
val = l[2][0]
else:
val = None
params_fgl[k][l[0]] = val
# Moment parameters
comp['names_moments_dict'] = {}
d = component.get('moments')
if d and config['fg_model'].get('use_moments'):
comp['moments_pameters'] = component['moments']
for k, l in component['moments'].items():
comp['names_moments_dict'][l[0]] = k
# Set Cl functions
comp['cl'] = {}
for k, c in component['cl'].items():
p1, p2 = k
# Add parameters only if we're using both polarization channels
if ((p1 in config['pol_channels'])
and (p2 in config['pol_channels'])):
cl_fnc = get_function(fgl, c)
comp['cl'][k] = cl_fnc(**(params_fgl[k]))
self.components[key] = comp
self.component_names.append(key)
self.component_order[key] = i_comp
i_comp += 1
self.n_components = len(self.component_names)
return
