def test_end_freqs(self) :
self.Data.calc_freq()
old_top = self.Data.freq[-1]
old_bot = self.Data.freq[0]
rebin_freq.rebin(self.Data, 0.9)
self.assertAlmostEqual(old_top, self.Data.freq[-1], places=-7)
self.assertAlmostEqual(old_bot, self.Data.freq[0], places=-7)
def test_rebin_get_freqs_right(self) :
"""Make sure that the frequencies calculated by the rebinner are
consistant with the ones calculated by calc_freq()."""
rebin_freq.rebin(self.Data, 2.0)
old_freq = sp.array(self.Data.freq)
self.Data.calc_freq()
self.assertTrue(sp.allclose(old_freq, self.Data.freq))
self.Data.verify()
self.assertEqual(self.Data.dims[-1], len(self.Data.freq))
def test_rebins_data_right(self) :
"""set all data to 0 except 1 entry, figure out the f, rebin and
check that only the closest new f is non-zero."""
self.Data.data[:,:,:,:] = 0
self.Data.data[5,2,0,324] = 1
self.Data.calc_freq()
oldf = self.Data.freq[324]
rebin_freq.rebin(self.Data, 2.0, mean=True)
new_ind = (abs(self.Data.freq - oldf)).argmin()
self.assertNotAlmostEqual(0, self.Data.data[5,2,0,new_ind])
self.Data.data[5,2,0,new_ind] = 0.0
self.assertTrue(sp.allclose(self.Data.data, 0.0))
def test_rebinned_cal(self) :
rebin_freq.rebin(self.CalData, 1.0)
DataCopy = copy.deepcopy(self.Data)
DataCopy.calc_freq()
calibrate.multiply_by_cal(self.Data, self.CalData)
gains = sp.array([1,sp.sqrt(5),sp.sqrt(5),5])
gains.shape = (1,4,1,1)
expected = (DataCopy.data*gains*DataCopy.freq)
self.assertTrue(ma.count_masked(self.Data.data <
sp.size(self.Data.data)*50.0/2000.0))
expected.mask = sp.array(self.Data.data.mask)
self.assertTrue(ma.allclose(expected, self.Data.data, 4))
def test_by_number_data_even(self) :
wbins = 8
# Set data = f.
self.Data.calc_freq()
self.Data.data[...] = self.Data.freq
delta = self.Data.field['CDELT1']
# Rebin.
rebin_freq.rebin(self.Data, wbins, by_nbins=True)
self.Data.verify()
# Except for the last bin, Data should still be freq.
self.Data.calc_freq()
self.assertTrue(sp.allclose(self.Data.data[:,:,:,:],
self.Data.freq[:], abs(delta)))
def action(self, Data, ) :
if self.params['n_bins_combined_freq'] > 1:
rebin_freq.rebin(Data, self.params['n_bins_combined_freq'],
True, True)
Data.add_history('Rebinned freq axis.',
('Number of freq bins averaged: '
+ str(self.params['n_bins_combined_freq']), ))
if self.params['n_bins_combined_time'] > 1:
rebin_time.rebin(Data, self.params['n_bins_combined_time'])
Data.add_history('Rebinned time axis.',
('Number of time bins averaged: '
+ str(self.params['n_bins_combined_time']), ))
return Data
def test_scales_rebined(self) :
self.Data.set_data(ma.ones((10,4,2,600)))
self.Data.verify()
rebin_freq.rebin(self.Data, 1.0)
DataCopy = copy.deepcopy(self.Data)
DataCopy.calc_freq()
calibrate.multiply_by_cal(self.Data, self.CalData)
gains = sp.array([1,sp.sqrt(5),sp.sqrt(5),5])
gains.shape = (1,4,1,1)
expected = (DataCopy.data*gains*DataCopy.freq)
# don't expect this test to be perfect, 4 figures good enough. Edge
# bins adversly affected by missing frequencies in CalData.
self.assertTrue(ma.allclose(expected[:,:,:1:-1],
self.Data.data[:,:,:1:-1], 4))
def test_by_number_mask(self):
wbins = 8
# Set data = f.
self.Data.data[...] = sp.arange(self.Data.data.shape[-1])
self.Data.data[3,1,1,54] = ma.masked
self.Data.data[5,1,1,70:82] = ma.masked
old_data = ma.copy(self.Data.data)
delta = self.Data.field['CDELT1']
# Rebin.
rebin_freq.rebin(self.Data, wbins, mean=True, by_nbins=True)
self.Data.verify()
# Except for the last bin, Data should still be freq.
self.assertAlmostEqual(self.Data.data[3,1,1,6],
ma.mean(old_data[3,1,1,48:56]))
self.assertTrue(self.Data.data[5,1,1,9] is ma.masked)
def test_by_number_data_odd(self) :
wbins = 9
# Set data = f.
self.Data.calc_freq()
self.Data.data[...] = self.Data.freq
delta = self.Data.field['CDELT1']
# Rebin.
rebin_freq.rebin(self.Data, wbins, by_nbins=True)
self.Data.verify()
# Except for the last bin, Data should still be freq.
self.Data.calc_freq()
self.assertTrue(sp.allclose(self.Data.data[:,:,:,:-1],
self.Data.freq[:-1], abs(delta)))
# In last bin, same, but tolerance is worse.
self.assertTrue(sp.allclose(self.Data.data[:,:,:,-1],
self.Data.freq[-1], abs(self.Data.field['CDELT1'])))
def test_by_number_axis(self) :
# For now rebin to a power of 2 for no residual
wbins = 2**4
# Get what we'd expect the new frequency axis to be
self.Data.calc_freq()
old_freq = self.Data.freq
new_freq = old_freq[wbins//2::wbins]
delta = self.Data.field['CDELT1']
# Rebin.
rebin_freq.rebin(self.Data, wbins, by_nbins=True)
self.Data.verify()
# Check that the spaceing is right.
self.assertAlmostEqual(wbins*delta, self.Data.field['CDELT1'])
# Check that the axis is what we would think.
self.Data.calc_freq()
self.assertTrue(sp.allclose(new_freq, self.Data.freq, atol=abs(delta)))
def test_rebin_runs(self) :
rebin_freq.rebin(self.Data, 1.0)
self.Data.verify()
self.assertAlmostEqual(-1.0, self.Data.field['CDELT1']/1.0e6)
