def setUp(self):
# Make a positive definite noise matrix, clean map, and dirty_map.
self.nra = 10
self.ndec = 5
self.nf = 20
self.shape = (self.nf, self.nra, self.ndec)
self.size = self.nra * self.ndec * self.nf
# Clean map.
clean_map = sp.empty(self.shape, dtype=float)
clean_map = al.make_vect(clean_map, axis_names=('freq', 'ra', 'dec'))
clean_map[...] = sp.sin(sp.arange(self.nf))[:,None,None]
clean_map *= sp.cos(sp.arange(self.nra))[:,None]
clean_map *= sp.cos(sp.arange(self.ndec))
# Noise inverse matrix.
noise_inv = sp.empty(self.shape * 2, dtype=float)
noise_inv = al.make_mat(noise_inv, axis_names=('freq', 'ra', 'dec')*2,
row_axes=(0, 1, 2), col_axes=(3, 4, 5))
rand_mat = rand.randn(*((self.size,) * 2))
information_factor = 1.e6 # K**-2
rand_mat = sp.dot(rand_mat, rand_mat.transpose()) * information_factor
noise_inv.flat[...] = rand_mat.flat
# Dirty map.
dirty_map = al.partial_dot(noise_inv, clean_map)
# Store in self.
self.clean_map = clean_map
self.noise_inv = noise_inv
self.dirty_map = dirty_map
def setUp(self):
# Make a positive definite noise matrix, clean map, and dirty_map.
self.nra = 10
self.ndec = 5
self.nf = 20
self.shape = (self.nf, self.nra, self.ndec)
self.size = self.nra * self.ndec * self.nf
# Clean map.
clean_map = sp.empty(self.shape, dtype=float)
clean_map = al.make_vect(clean_map, axis_names=('freq', 'ra', 'dec'))
clean_map[...] = sp.sin(sp.arange(self.nf))[:, None, None]
clean_map *= sp.cos(sp.arange(self.nra))[:, None]
clean_map *= sp.cos(sp.arange(self.ndec))
# Noise inverse matrix.
noise_inv = sp.empty(self.shape * 2, dtype=float)
noise_inv = al.make_mat(noise_inv,
axis_names=('freq', 'ra', 'dec') * 2,
row_axes=(0, 1, 2),
col_axes=(3, 4, 5))
rand_mat = rand.randn(*((self.size, ) * 2))
information_factor = 1.e6 # K**-2
rand_mat = sp.dot(rand_mat, rand_mat.transpose()) * information_factor
noise_inv.flat[...] = rand_mat.flat
# Dirty map.
dirty_map = al.partial_dot(noise_inv, clean_map)
# Store in self.
self.clean_map = clean_map
self.noise_inv = noise_inv
self.dirty_map = dirty_map
def test_apply_time_axis(self):
# The function that this is testing hasn't been implemented. Test
# disabled.
time_stream, ra, dec, az, el, time, mask_inds = \
self.DM.get_all_trimmed()
P = dirty_map.Pointing(('ra', 'dec'), (ra, dec), self.map, 'linear')
pointing_matrix = P.get_matrix()
gridded_data_mult = al.partial_dot(time_stream, pointing_matrix)
gridded_data_fast = P.apply_to_time_axis(time_stream)
self.assertTrue(sp.allclose(gridded_data_mult, gridded_data_fast))
def test_apply_time_axis(self):
# The function that this is testing hasn't been implemented. Test
# disabled.
time_stream, ra, dec, az, el, time, mask_inds = \
self.DM.get_all_trimmed()
P = dirty_map.Pointing(('ra', 'dec'), (ra, dec), self.map, 'linear')
pointing_matrix = P.get_matrix()
gridded_data_mult = al.partial_dot(time_stream,
pointing_matrix)
gridded_data_fast = P.apply_to_time_axis(time_stream)
self.assertTrue(sp.allclose(gridded_data_mult, gridded_data_fast))
def test_solve_eig_bad_ind(self):
# Set all the information in one pixel to nil.
self.noise_inv[17,3,1,...] = 0
self.noise_inv[...,17,3,1] = 0
self.dirty_map = al.partial_dot(self.noise_inv, self.clean_map)
self.eig()
new_clean_map, noise_diag = clean_map.solve_from_eig(
self.noise_evalsinv, self.noise_evects, self.dirty_map, True,
feedback=0)
self.clean_map[17,3,1] = 0
self.assertTrue(sp.allclose(new_clean_map, self.clean_map))
def test_solve_eig_bad_ind(self):
# Set all the information in one pixel to nil.
self.noise_inv[17, 3, 1, ...] = 0
self.noise_inv[..., 17, 3, 1] = 0
self.dirty_map = al.partial_dot(self.noise_inv, self.clean_map)
self.eig()
new_clean_map, noise_diag = clean_map.solve_from_eig(
self.noise_evalsinv,
self.noise_evects,
self.dirty_map,
True,
feedback=0)
self.clean_map[17, 3, 1] = 0
self.assertTrue(sp.allclose(new_clean_map, self.clean_map))
def test_build_noise(self):
map = self.map
time_stream, ra, dec, az, el, time, mask_inds = \
self.DM.get_all_trimmed()
nt = len(time)
Noise = dirty_map.Noise(time_stream, time)
thermal_noise_levels = sp.zeros((nf_d)) + 0.04 # Kelvin**2
Noise.add_thermal(thermal_noise_levels)
Noise.add_mask(mask_inds)
self.assertTrue(sp.alltrue(Noise.diagonal[mask_inds] > 10))
Noise.deweight_time_mean()
Noise.deweight_time_slope()
Noise.add_correlated_over_f(0.01, -1.2, 0.1)
Noise.finalize()
#### Test the full inverse.
# Frist get a full representation of the noise matrix
#tmp_mat = sp.zeros((nf_d, nt, nf_d, nt))
#tmp_mat.flat[::nt*nf_d + 1] += Noise.diagonal.flat
#for jj in xrange(Noise.time_modes.shape[0]):
# tmp_mat += (Noise.time_mode_noise[jj,:,None,:,None]
# * Noise.time_modes[jj,None,:,None,None]
# * Noise.time_modes[jj,None,None,None,:])
#for jj in xrange(Noise.freq_modes.shape[0]):
# tmp_mat += (Noise.freq_mode_noise[jj,None,:,None,:]
# * Noise.freq_modes[jj,:,None,None,None]
# * Noise.freq_modes[jj,None,None,:,None])
tmp_mat = Noise.get_mat()
tmp_mat.shape = (nt*nf_d, nt*nf_d)
# Check that the matrix I built for testing is indeed symetric.
self.assertTrue(sp.allclose(tmp_mat, tmp_mat.transpose()))
noise_inv = Noise.get_inverse()
noise_inv.shape = (nt*nf_d, nt*nf_d)
# Check that the production matrix is symetric.
self.assertTrue(sp.allclose(noise_inv, noise_inv.transpose()))
tmp_eye = sp.dot(tmp_mat, noise_inv)
#print tmp_eye
noise_inv.shape = (nf_d, nt, nf_d, nt)
self.assertTrue(sp.allclose(tmp_eye, sp.identity(nt*nf_d)))
# Check that the calculation of the diagonal is correct.
noise_inv_diag = Noise.get_inverse_diagonal()
self.assertTrue(sp.allclose(noise_inv_diag.flat,
noise_inv.flat[::nf_d*nt + 1]))
#### Test the noise weighting of the data.
noise_weighted_data = Noise.weight_time_stream(time_stream)
self.assertTrue(sp.allclose(noise_weighted_data, al.dot(noise_inv,
time_stream)))
#### Test making noise in map space.
# First make the noise matrix by brute force.
P = dirty_map.Pointing(("ra", "dec"), (ra, dec), map, 'nearest')
P_mat = P.get_matrix()
tmp_map_noise_inv = al.partial_dot(noise_inv,
P_mat)
tmp_map_noise_inv = al.partial_dot(P_mat.mat_transpose(),
tmp_map_noise_inv)
# I mess up the meta data by doing this, but rotate the axes so they
# are in the desired order.
tmp_map_noise_inv = sp.rollaxis(tmp_map_noise_inv, 2, 0)
# Now use fast methods.
map_noise_inv = sp.zeros((nf_d, nra_d, ndec_d, nf_d, nra_d, ndec_d),
dtype=float)
map_noise_inv = al.make_mat(map_noise_inv, axis_names=('freq', 'ra',
'dec', 'freq', 'ra', 'dec'), row_axes=(0, 1, 2),
col_axes=(3, 4, 5))
start = time_module.clock()
for ii in xrange(nf_d):
for jj in xrange(nra_d):
P.noise_to_map_domain(Noise, ii, jj,
map_noise_inv[ii,jj,:,:,:,:])
stop = time_module.clock()
#print "Constructing map noise took %5.2f seconds." % (stop - start)
self.assertTrue(sp.allclose(map_noise_inv, tmp_map_noise_inv))
def test_build_noise(self):
map = self.map
time_stream, ra, dec, az, el, time, mask_inds = \
self.DM.get_all_trimmed()
nt = len(time)
Noise = dirty_map.Noise(time_stream, time)
thermal_noise_levels = sp.zeros((nf_d)) + 0.04 # Kelvin**2
Noise.add_thermal(thermal_noise_levels)
Noise.add_mask(mask_inds)
self.assertTrue(sp.alltrue(Noise.diagonal[mask_inds] > 10))
Noise.deweight_time_mean()
Noise.deweight_time_slope()
Noise.add_correlated_over_f(0.01, -1.2, 0.1)
Noise.finalize()
#### Test the full inverse.
# Frist get a full representation of the noise matrix
#tmp_mat = sp.zeros((nf_d, nt, nf_d, nt))
#tmp_mat.flat[::nt*nf_d + 1] += Noise.diagonal.flat
#for jj in xrange(Noise.time_modes.shape[0]):
# tmp_mat += (Noise.time_mode_noise[jj,:,None,:,None]
# * Noise.time_modes[jj,None,:,None,None]
# * Noise.time_modes[jj,None,None,None,:])
#for jj in xrange(Noise.freq_modes.shape[0]):
# tmp_mat += (Noise.freq_mode_noise[jj,None,:,None,:]
# * Noise.freq_modes[jj,:,None,None,None]
# * Noise.freq_modes[jj,None,None,:,None])
tmp_mat = Noise.get_mat()
tmp_mat.shape = (nt * nf_d, nt * nf_d)
# Check that the matrix I built for testing is indeed symetric.
self.assertTrue(sp.allclose(tmp_mat, tmp_mat.transpose()))
noise_inv = Noise.get_inverse()
noise_inv.shape = (nt * nf_d, nt * nf_d)
# Check that the production matrix is symetric.
self.assertTrue(sp.allclose(noise_inv, noise_inv.transpose()))
tmp_eye = sp.dot(tmp_mat, noise_inv)
#print tmp_eye
noise_inv.shape = (nf_d, nt, nf_d, nt)
self.assertTrue(sp.allclose(tmp_eye, sp.identity(nt * nf_d)))
# Check that the calculation of the diagonal is correct.
noise_inv_diag = Noise.get_inverse_diagonal()
self.assertTrue(
sp.allclose(noise_inv_diag.flat, noise_inv.flat[::nf_d * nt + 1]))
#### Test the noise weighting of the data.
noise_weighted_data = Noise.weight_time_stream(time_stream)
self.assertTrue(
sp.allclose(noise_weighted_data, al.dot(noise_inv, time_stream)))
#### Test making noise in map space.
# First make the noise matrix by brute force.
P = dirty_map.Pointing(("ra", "dec"), (ra, dec), map, 'nearest')
P_mat = P.get_matrix()
tmp_map_noise_inv = al.partial_dot(noise_inv, P_mat)
tmp_map_noise_inv = al.partial_dot(P_mat.mat_transpose(),
tmp_map_noise_inv)
# I mess up the meta data by doing this, but rotate the axes so they
# are in the desired order.
tmp_map_noise_inv = sp.rollaxis(tmp_map_noise_inv, 2, 0)
# Now use fast methods.
map_noise_inv = sp.zeros((nf_d, nra_d, ndec_d, nf_d, nra_d, ndec_d),
dtype=float)
map_noise_inv = al.make_mat(map_noise_inv,
axis_names=('freq', 'ra', 'dec', 'freq',
'ra', 'dec'),
row_axes=(0, 1, 2),
col_axes=(3, 4, 5))
start = time_module.clock()
for ii in xrange(nf_d):
for jj in xrange(nra_d):
P.noise_to_map_domain(Noise, ii, jj,
map_noise_inv[ii, jj, :, :, :, :])
stop = time_module.clock()
#print "Constructing map noise took %5.2f seconds." % (stop - start)
self.assertTrue(sp.allclose(map_noise_inv, tmp_map_noise_inv))
