def setup_class(klass):
import os
klass.curdir = os.path.dirname(__file__)
klass.datadir = os.path.join(klass.curdir, 'data')
klass.config_file = \
os.path.abspath(os.path.join(klass.datadir, "calibrators.ini"))
klass.config_file_empty = \
os.path.abspath(os.path.join(klass.datadir,
"calibrators_nocal.ini"))
klass.config = read_config(klass.config_file)
klass.caldir = os.path.join(klass.datadir, 'sim', 'calibration')
klass.caldir2 = os.path.join(klass.datadir, 'sim', 'calibration2')
klass.caldir3 = os.path.join(klass.datadir, 'sim', 'calibration_bad')
klass.crossdir = os.path.join(klass.datadir, 'sim', 'crossscans')
if not os.path.exists(klass.caldir):
print('Fake calibrators: DummyCal, 1 Jy.')
mkdir_p(klass.caldir)
sim_crossscans(5, klass.caldir)
if not os.path.exists(klass.caldir2):
print('Fake calibrators: DummyCal2, 1 Jy.')
mkdir_p(klass.caldir2)
sim_crossscans(5, klass.caldir2, srcname='DummyCal2')
if not os.path.exists(klass.caldir3):
print('Fake calibrators: DummyCal2, wrong flux 0.52 Jy.')
mkdir_p(klass.caldir3)
sim_crossscans(1,
klass.caldir3,
srcname='DummyCal2',
scan_func=source_scan_func)
if not os.path.exists(klass.crossdir):
print('Fake cross scans: DummySrc, 0.52 Jy.')
mkdir_p(klass.crossdir)
sim_crossscans(5,
klass.crossdir,
srcname='DummySrc',
scan_func=source_scan_func)
klass.scan_list = \
list_scans(klass.caldir, ['./']) + \
list_scans(klass.caldir2, ['./']) + \
list_scans(klass.crossdir, ['./'])
klass.scan_list.sort()
caltable = CalibratorTable()
caltable.from_scans(klass.scan_list)
caltable.update()
klass.calfile = os.path.join(klass.curdir, 'test_calibration.hdf5')
caltable.write(klass.calfile, overwrite=True)
caltable.write(klass.calfile.replace('hdf5', 'csv'))
def test_check_consistency(self):
caltable = CalibratorTable.read(self.calfile, path='table')
res = caltable.check_consistency(channel='Feed0_LCP')
assert np.all(res)
res = caltable.check_consistency(channel='Feed0_RCP')
assert np.all(res)
res = caltable.check_consistency()
assert np.all(res)
def test_calibration_plot_two_cols(self):
"""Simple calibration from scans."""
caltable = CalibratorTable.read(self.calfile, path='table')
caltable.plot_two_columns('RA',
"Flux/Counts",
xerrcol="RA err",
yerrcol="Flux/Counts Err",
test=True)
def test_calibration_counts(self):
"""Simple calibration from scans."""
caltable = CalibratorTable.read(self.calfile, path='table')
caltable = caltable[compare_strings(caltable['Source'], 'DummyCal')]
caltable_0 = caltable[compare_strings(caltable['Chan'], 'Feed0_LCP')]
assert np.all(
np.abs(caltable_0['Counts'] - 100.) < 3 * caltable_0['Counts Err'])
caltable_1 = caltable[compare_strings(caltable['Chan'], 'Feed0_RCP')]
assert np.all(
np.abs(caltable_1['Counts'] - 80.) < 3 * caltable_1['Counts Err'])
def test_Jy_over_counts_rough_one_bad_value(self, logger, caplog):
caltable = CalibratorTable.read(self.calfile, path='table')
flux_quantity = _get_flux_quantity('Jy/beam')
caltable[flux_quantity + "/Counts"][0] += \
caltable[flux_quantity + "/Counts Err"][0] * 2000
Jc, Jce = caltable.Jy_over_counts_rough(channel='Feed0_LCP',
map_unit='Jy/beam')
assert 'Outliers: ' in caplog.text
Cj, Cje = caltable.counts_over_Jy(channel='Feed0_LCP')
np.testing.assert_allclose(Jc, 1 / Cj)
def test_calibration_width(self):
"""Simple calibration from scans."""
caltable = CalibratorTable.read(self.calfile, path='table')
caltable0 = caltable[compare_strings(caltable['Chan'], 'Feed0_LCP')]
assert np.all(
np.abs(caltable0['Width'] - 2.5/60.) < 5 * caltable0['Width Err'])
caltable1 = caltable[compare_strings(caltable['Chan'], 'Feed0_RCP')]
assert np.all(
np.abs(caltable1['Width'] - 2.5/60.) < 5 * caltable1['Width Err'])
beam, beam_err = caltable.beam_width(channel='Feed0_LCP')
assert np.all(beam - np.radians(2.5/60) < 3 * beam_err)
def test_check_consistency_fails_with_bad_data(self):
scan_list = \
list_scans(self.caldir, ['./']) + \
list_scans(self.caldir2, ['./']) + \
list_scans(self.caldir3, ['./']) + \
list_scans(self.crossdir, ['./'])
scan_list.sort()
caltable = CalibratorTable()
caltable.from_scans(scan_list)
caltable.update()
res = caltable.check_consistency(channel='Feed0_LCP')
assert not np.all(res)
def test_calibrated_crossscans(self):
caltable = CalibratorTable.read(self.calfile, path='table')
dummy_flux, dummy_flux_err = \
caltable.calculate_src_flux(source='DummySrc', channel='Feed0_LCP')
assert (dummy_flux[0] - 0.52) < dummy_flux_err[0] * 3
def test_Jy_over_counts_and_back(self):
caltable = CalibratorTable.read(self.calfile, path='table')
Jc, Jce = caltable.Jy_over_counts(channel='Feed0_LCP')
Cj, Cje = caltable.counts_over_Jy(channel='Feed0_LCP')
np.testing.assert_allclose(Jc, 1 / Cj)
def test_check_up_to_date_empty_return_false(self):
caltable = CalibratorTable()
assert not caltable.check_up_to_date()
def test_calibration_show(self):
"""Simple calibration from scans."""
caltable = CalibratorTable.read(self.calfile, path='table')
caltable.show()
def test_bad_file_generic_error(self, logger, caplog):
caltable = CalibratorTable()
caltable.from_scans([os.path.join(self.config['datadir'],
'calibrators', 'bubu.fits')])
assert "Error while processing" in caplog.text
def test_update_empty_return_none(self):
caltable = CalibratorTable()
assert caltable.update() is None
def test_bad_file_missing_key(self, logger, caplog):
caltable = CalibratorTable()
caltable.from_scans([os.path.join(self.config['datadir'],
'calibrators', 'summary.fits')])
assert "Missing key" in caplog.text
def setup_class(klass):
import os
klass.curdir = os.path.dirname(__file__)
klass.datadir = os.path.join(klass.curdir, 'data')
klass.sim_dir = os.path.join(klass.datadir, 'sim')
klass.obsdir_ra = os.path.join(klass.datadir, 'sim', 'gauss_ra')
klass.obsdir_dec = os.path.join(klass.datadir, 'sim', 'gauss_dec')
klass.config_file = \
os.path.abspath(os.path.join(klass.sim_dir, 'test_config_sim.ini'))
klass.caldir = os.path.join(klass.datadir, 'sim', 'calibration')
klass.simulated_flux = 0.25
# First off, simulate a beamed observation -------
sim_config_file(klass.config_file, add_garbage=True, prefix="./")
if (not os.path.exists(klass.obsdir_ra)) or \
(not os.path.exists(klass.obsdir_dec)):
mkdir_p(klass.obsdir_ra)
mkdir_p(klass.obsdir_dec)
print('Fake map: Point-like (but Gaussian beam shape), '
'{} Jy.'.format(klass.simulated_flux))
sim_map(klass.obsdir_ra, klass.obsdir_dec)
defective_dir = os.path.join(klass.sim_dir, 'defective')
if not os.path.exists(defective_dir):
shutil.copytree(os.path.join(klass.datadir, 'calibrators'),
defective_dir)
# Copy skydip scan
skydip_dir = os.path.join(klass.datadir, 'gauss_skydip')
new_skydip_dir = os.path.join(klass.sim_dir, 'gauss_skydip')
if os.path.exists(skydip_dir) and not os.path.exists(new_skydip_dir):
shutil.copytree(skydip_dir, new_skydip_dir)
caltable = CalibratorTable()
caltable.from_scans(glob.glob(os.path.join(klass.caldir, '*.fits')),
debug=True)
caltable.update()
klass.calfile = os.path.join(klass.datadir, 'calibrators.hdf5')
caltable.write(klass.calfile, overwrite=True)
klass.config = read_config(klass.config_file)
klass.raonly = os.path.abspath(
os.path.join(klass.datadir, 'test_raonly.ini'))
klass.deconly = os.path.abspath(
os.path.join(klass.datadir, 'test_deconly.ini'))
if HAS_PYREGION:
excluded_xy, excluded_radec = \
_excluded_regions_from_args([os.path.join(klass.datadir,
"center.reg")])
else:
excluded_xy, excluded_radec = None, None
klass.scanset = ScanSet(klass.config_file,
nosub=False,
norefilt=False,
debug=True,
avoid_regions=excluded_radec)
klass.scanset.write('test.hdf5', overwrite=True)
klass.stdinfo = {}
klass.stdinfo['FLAG'] = None
klass.stdinfo['zap'] = intervals()
klass.stdinfo['base'] = intervals()
klass.stdinfo['fitpars'] = np.array([0, 0])
def scan_no(scan_str):
basename = os.path.splitext(os.path.basename(scan_str))[0]
return int(basename.replace('Dec', '').replace('Ra', ''))
klass.dec_scans = \
dict([(scan_no(s), s)
for s in klass.scanset.scan_list if 'Dec' in s])
klass.ra_scans = \
dict([(scan_no(s), s)
for s in klass.scanset.scan_list if 'Ra' in s])
klass.n_ra_scans = max(list(klass.ra_scans.keys()))
klass.n_dec_scans = max(list(klass.dec_scans.keys()))
if HAS_MPL:
plt.ioff()
def test_get_fluxes_empty_return_none(self):
caltable = CalibratorTable()
assert caltable.get_fluxes() is None
def test_check_class_from_file(self):
caltable = CalibratorTable.read(self.calfile, path='table')
assert caltable.check_up_to_date()
def test_check_class(self):
caltable = CalibratorTable()
caltable.from_scans(self.scan_list)
with pytest.warns(UserWarning):
caltable.check_up_to_date()
def test_check_not_empty(self):
caltable = CalibratorTable()
assert not caltable.check_not_empty()
def test_import_calibratortable():
from srttools import CalibratorTable
s = CalibratorTable()
assert isinstance(s, Table)