def test_antenna_to_antenna():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf2 = uvf.copy()
uvf.to_antenna(uvc)
nt.assert_equal(uvf, uvf2)
def test_total_quality_array_size():
"""
Test that total quality array defaults to the proper size
"""
cal_in = UVCal()
testfile = os.path.join(DATA_PATH, "zen.2457698.40355.xx.gain.calfits")
cal_in.read_calfits(testfile)
# Create filler total quality array
cal_in.total_quality_array = np.zeros(
cal_in._total_quality_array.expected_shape(cal_in))
proper_shape = (cal_in.Nspws, cal_in.Nfreqs, cal_in.Ntimes, cal_in.Njones)
assert cal_in.total_quality_array.shape == proper_shape
del cal_in
# also test delay-type calibrations
cal_in = UVCal()
testfile = os.path.join(DATA_PATH, "zen.2457698.40355.xx.delay.calfits")
cal_in.read_calfits(testfile)
cal_in.total_quality_array = np.zeros(
cal_in._total_quality_array.expected_shape(cal_in))
proper_shape = (cal_in.Nspws, 1, cal_in.Ntimes, cal_in.Njones)
assert cal_in.total_quality_array.shape == proper_shape
del cal_in
def test_gainHC(self):
fn = os.path.join(DATA_PATH, 'test_input',
'zen.2457698.40355.xx.HH.uvc.omni.calfits')
meta, gains, vis, xtalk = omni.from_fits(fn)
meta['inttime'] = np.diff(meta['times'])[0] * 60 * 60 * 24
optional = {
'observer': 'heracal'
} #because it's easier than changing the fits header
hc = cal_formats.HERACal(meta, gains, **optional)
uv = UVCal()
uv.read_calfits(
os.path.join(DATA_PATH, 'test_input',
'zen.2457698.40355.xx.HH.uvc.omni.calfits'))
for param in hc:
if param == '_history':
continue
elif param == '_time_range': # why do we need this?
nt.assert_equal(
np.testing.assert_almost_equal(
getattr(hc, param).value,
getattr(uv, param).value, 5), None)
elif param == '_extra_keywords':
continue
else:
if "_antenna_" in param:
param = param[1:]
nt.assert_true(
np.all(getattr(hc, param) == getattr(uv, param)))
def test_calculate_metric(self):
# setup
uv = UVData()
uv.read_miriad(test_d_file)
# Use Kt=3 because test file only has three times
uvf = xrfi.calculate_metric(uv, 'detrend_medfilt', Kt=3)
nt.assert_equal(uvf.mode, 'metric')
nt.assert_equal(uvf.type, 'baseline')
inds = uv.antpair2ind(uv.ant_1_array[0], uv.ant_2_array[0])
wf = uv.get_data(uv.ant_1_array[0], uv.ant_2_array[0])
filtered = xrfi.detrend_medfilt(np.abs(wf), Kt=3)
nt.assert_true(np.allclose(filtered, uvf.metric_array[inds, 0, :, 0]))
# Cal gains version
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = xrfi.calculate_metric(uvc, 'detrend_medfilt', Kt=3, Kf=3)
nt.assert_equal(uvf.mode, 'metric')
nt.assert_equal(uvf.type, 'antenna')
wf = uvc.gain_array[0, 0, :, :, 0]
filtered = xrfi.detrend_medfilt(np.abs(wf), Kt=3, Kf=3)
nt.assert_true(np.allclose(filtered, uvf.metric_array[0, 0, :, :, 0]))
# Cal chisq version
uvf = xrfi.calculate_metric(uvc, 'detrend_medfilt', gains=False, chisq=True,
Kt=3, Kf=3)
nt.assert_equal(uvf.mode, 'metric')
nt.assert_equal(uvf.type, 'antenna')
wf = uvc.quality_array[0, 0, :, :, 0]
filtered = xrfi.detrend_medfilt(np.abs(wf), Kt=3, Kf=3)
nt.assert_true(np.allclose(filtered, uvf.metric_array[0, 0, :, :, 0]))
def test_spw_zero_indexed_delay():
"""
Test that old files with zero-indexed spw array are read correctly for delay-type
"""
cal_in = UVCal()
cal_out = UVCal()
testfile = os.path.join(DATA_PATH, 'zen.2457698.40355.xx.delay.calfits')
write_file = os.path.join(DATA_PATH, 'test/outtest_firstcal.fits')
cal_in.read_calfits(testfile)
cal_in.write_calfits(write_file, clobber=True)
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
hdunames = uvutils._fits_indexhdus(F)
ant_hdu = F[hdunames['ANTENNAS']]
flag_hdu = F[hdunames['FLAGS']]
flag_hdr = flag_hdu.header
primary_hdr['CRVAL5'] = 0
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, ant_hdu])
flag_hdu = fits.ImageHDU(data=flag_hdu.data, header=flag_hdr)
hdulist.append(flag_hdu)
hdulist.writeto(write_file, overwrite=True)
cal_out.read_calfits(write_file)
assert cal_in == cal_out
def test_read_noversion_history(tmp_path):
"""
Test that version info gets added to the history if it's missing
"""
cal_in = UVCal()
cal_out = UVCal()
testfile = os.path.join(DATA_PATH, "zen.2457698.40355.xx.gain.calfits")
write_file = str(tmp_path / "outtest_omnical.fits")
write_file2 = str(tmp_path / "outtest_omnical2.fits")
cal_in.read_calfits(testfile)
cal_in.write_calfits(write_file, clobber=True)
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
hdunames = uvutils._fits_indexhdus(fname)
ant_hdu = fname[hdunames["ANTENNAS"]]
primary_hdr["HISTORY"] = ""
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, ant_hdu])
hdulist.writeto(write_file2, overwrite=True)
hdulist.close()
cal_out.read_calfits(write_file2)
assert cal_in == cal_out
def test_calculate_metric_errors(self):
uvc = UVCal()
uvc.read_calfits(test_c_file)
nt.assert_raises(ValueError, xrfi.calculate_metric, 5, 'detrend_medfilt')
nt.assert_raises(KeyError, xrfi.calculate_metric, uvc, 'my_awesome_algorithm')
nt.assert_raises(ValueError, xrfi.calculate_metric, uvc, 'detrend_medfilt',
gains=False, chisq=False)
def test_add_antenna():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uv1 = UVFlag(uvc)
uv2 = copy.deepcopy(uv1)
uv2.ant_array += 100 # Arbitrary
uv3 = uv1.__add__(uv2, axis='antenna')
nt.assert_true(
np.array_equal(np.concatenate((uv1.ant_array, uv2.ant_array)),
uv3.ant_array))
nt.assert_true(
np.array_equal(
np.concatenate((uv1.metric_array, uv2.metric_array), axis=0),
uv3.metric_array))
nt.assert_true(
np.array_equal(
np.concatenate((uv1.weights_array, uv2.weights_array), axis=0),
uv3.weights_array))
nt.assert_true(np.array_equal(uv1.freq_array, uv3.freq_array))
nt.assert_true(np.array_equal(uv1.time_array, uv3.time_array))
nt.assert_true(np.array_equal(uv1.lst_array, uv3.lst_array))
nt.assert_true(uv3.type == 'antenna')
nt.assert_true(uv3.mode == 'metric')
nt.assert_true(
np.array_equal(uv1.polarization_array, uv3.polarization_array))
nt.assert_true('Data combined along antenna axis with ' +
hera_qm_version_str in uv3.history)
def test_read_noversion_history():
"""
Test that version info gets added to the history if it's missing
"""
cal_in = UVCal()
cal_out = UVCal()
testfile = os.path.join(DATA_PATH, 'zen.2457698.40355.xx.gain.calfits')
write_file = os.path.join(DATA_PATH, 'test/outtest_omnical.fits')
cal_in.read_calfits(testfile)
cal_in.write_calfits(write_file, clobber=True)
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
hdunames = uvutils._fits_indexhdus(F)
ant_hdu = F[hdunames['ANTENNAS']]
primary_hdr['HISTORY'] = ''
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, ant_hdu])
hdulist.writeto(write_file, overwrite=True)
cal_out.read_calfits(write_file)
assert cal_in == cal_out
def test_extra_keywords_warnings(tmp_path):
cal_in = UVCal()
calfits_file = os.path.join(DATA_PATH, "zen.2457698.40355.xx.gain.calfits")
testfile = str(tmp_path / "outtest_omnical.fits")
cal_in.read_calfits(calfits_file)
# check for warnings with extra_keywords keys that are too long
cal_in.extra_keywords["test_long_key"] = True
uvtest.checkWarnings(
cal_in.check,
message=[
"key test_long_key in extra_keywords is longer than 8 characters"
],
)
uvtest.checkWarnings(
cal_in.write_calfits,
[testfile],
{
"run_check": False,
"clobber": True
},
message=[
"key test_long_key in extra_keywords is longer than 8 characters"
],
)
return
def test_read_multi(tmp_path):
"""Test reading in multiple files."""
testdir2 = os.path.join(DATA_PATH, "fhd_cal_data/set2")
obs_testfile_list = [
obs_testfile,
os.path.join(testdir2, testfile_prefix + "obs.sav"),
]
cal_testfile_list = [
cal_testfile,
os.path.join(testdir2, testfile_prefix + "cal.sav"),
]
settings_testfile_list = [
settings_testfile,
os.path.join(testdir2, testfile_prefix + "settings.txt"),
]
fhd_cal = UVCal()
calfits_cal = UVCal()
with uvtest.check_warnings(UserWarning,
"UVParameter diffuse_model does not match"):
fhd_cal.read_fhd_cal(cal_testfile_list,
obs_testfile_list,
settings_file=settings_testfile_list)
outfile = str(tmp_path / "outtest_FHDcal_1061311664.calfits")
fhd_cal.write_calfits(outfile, clobber=True)
calfits_cal.read_calfits(outfile)
assert fhd_cal == calfits_cal
def __init__(self, file_root, time=0, freq=0, level="approx"):
# Get model
fname = file_root + ".uvh5"
print("Get true model from", fname)
uvdata = UVData()
uvdata.read_uvh5(fname)
assert uvdata.Nants_data == uvdata.Nants_telescope, \
"Not all antennas have data"
nant = uvdata.Nants_data
# Map antenna numbers to the vis index
ants_to_baseline = []
for i in range(nant):
for j in range(i + 1, nant):
ants_to_baseline.append((i, j))
assert uvdata.Nbls-nant == len(ants_to_baseline), \
"Data does not contain expected number of baselines"
nvis = len(ants_to_baseline)
# Load model
V_model = np.zeros(nvis, dtype=np.complex64)
for i, bl in enumerate(ants_to_baseline):
V_model[i] = uvdata.get_data(bl[0], bl[1], "XX")[time][freq]
# Get true gains
fname = file_root + ".calfits"
print("Get true gains from", fname)
uvc = UVCal()
uvc.read_calfits(fname)
g_bar = np.zeros(nant, dtype=np.complex64)
for i in range(nant):
g_bar[i] = uvc.get_gains(i)[0, 0]
# Get V_obs
fname = file_root + "_g.uvh5"
print("Get V_obs from", fname)
uvdata = UVData()
uvdata.read_uvh5(fname)
assert uvdata.Nants_data == uvdata.Nants_telescope, \
"Not all antennas have data"
assert uvdata.Nbls-nant == nvis, \
"Data does not contain expected number of baselines"
# Load V_obs
V = np.zeros(nvis, dtype=np.complex64)
for i, bl in enumerate(ants_to_baseline):
V[i] = uvdata.get_data(bl[0], bl[1], "XX")[time][freq]
self.level = level
self.nant = nant
self.nvis = nvis
self.g_bar = g_bar
self.V_model = V_model
self.x = np.zeros(g_bar.size, dtype=np.complex64)
self.V_obs = V
self.obs_variance = np.full(V.size, 1)
self.redundant_groups, _, _ = uvdata.get_redundancies()
def test_combine_metrics_wrong_shape():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
np.random.seed(44)
uvf.metric_array = np.random.normal(size=uvf.metric_array.shape)
uvf2 = uvf.copy()
uvf2.to_waterfall()
pytest.raises(ValueError, uvf.combine_metrics, uvf2)
def test_to_metric_antenna():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc, mode='flag')
uvf.flag_array[10, :, :, 1, :] = True
uvf.flag_array[15, :, 3, :, :] = True
uvf.to_metric(convert_wgts=True)
assert np.isclose(uvf.weights_array[10, :, :, 1, :], 0.0).all()
assert np.isclose(uvf.weights_array[15, :, 3, :, :], 0.0).all()
def test_read_write_ant():
uv = UVCal()
uv.read_calfits(test_c_file)
uvf = UVFlag(uv, mode='flag', label='test')
uvf.write(test_outfile, clobber=True)
uvf2 = UVFlag(test_outfile)
# Update history to match expected additions that were made
uvf.history += 'Written by ' + hera_qm_version_str
uvf.history += ' Read by ' + hera_qm_version_str
nt.assert_true(uvf.__eq__(uvf2, check_history=True))
def test_break_read_fhdcal():
"""Try various cases of missing files."""
fhd_cal = UVCal()
pytest.raises(TypeError, fhd_cal.read_fhd_cal, cal_testfile) # Missing obs
with uvtest.check_warnings(UserWarning, "No settings file"):
fhd_cal.read_fhd_cal(cal_testfile, obs_testfile)
# Check only pyuvdata version history with no settings file
assert fhd_cal.history == "\n" + fhd_cal.pyuvdata_version_str
def test_to_waterfall_ant():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf.weights_array = np.ones_like(uvf.weights_array)
uvf.to_waterfall()
nt.assert_true(uvf.type == 'waterfall')
nt.assert_true(uvf.metric_array.shape == (len(uvf.time_array),
len(uvf.freq_array),
len(uvf.polarization_array)))
nt.assert_true(uvf.weights_array.shape == uvf.metric_array.shape)
def test_combine_metrics_not_inplace():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
np.random.seed(44)
uvf.metric_array = np.random.normal(size=uvf.metric_array.shape)
uvf2 = uvf.copy()
uvf2.metric_array *= 2
uvf3 = uvf.copy()
uvf3.metric_array *= 3
uvf4 = uvf.combine_metrics([uvf2, uvf3], inplace=False)
factor = np.sqrt((1 + 4 + 9) / 3.)
assert np.allclose(uvf4.metric_array, np.abs(uvf.metric_array) * factor)
def test_read_fhdcal_fit_write_read_calfits(tmp_path):
# do it again with fit gains (rather than raw)
fhd_cal = UVCal()
calfits_cal = UVCal()
fhd_cal.read_fhd_cal(cal_testfile,
obs_testfile,
settings_file=settings_testfile,
raw=False)
outfile = str(tmp_path / "outtest_FHDcal_1061311664.calfits")
fhd_cal.write_calfits(outfile, clobber=True)
calfits_cal.read_calfits(outfile)
assert fhd_cal == calfits_cal
return
def test_to_antenna_metric():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf.to_waterfall()
uvf.metric_array[0, 10, 0] = 3.2 # Fill in time0, chan10
uvf.metric_array[1, 15, 0] = 2.1 # Fill in time1, chan15
uvf.to_antenna(uvc)
assert np.all(uvf.ant_array == uvc.ant_array)
assert np.all(uvf.time_array == uvc.time_array)
assert np.all(uvf.metric_array[:, 0, 10, 0, 0] == 3.2)
assert np.all(uvf.metric_array[:, 0, 15, 1, 0] == 2.1)
assert np.isclose(uvf.metric_array.mean(),
(3.2 + 2.1) * uvc.Nants_data / uvf.metric_array.size)
def test_init_waterfall_flag():
uv = UVCal()
uv.read_calfits(test_c_file)
uvf = UVFlag(uv, waterfall=True, mode='flag')
assert uvf.flag_array.shape == (uv.Ntimes, uv.Nfreqs, uv.Njones)
assert not np.any(uvf.flag_array)
assert uvf.weights_array.shape == (uv.Ntimes, uv.Nfreqs, uv.Njones)
assert np.all(uvf.weights_array == 1)
assert uvf.type == 'waterfall'
assert uvf.mode == 'flag'
assert np.all(uvf.time_array == np.unique(uv.time_array))
assert np.all(uvf.freq_array == uv.freq_array[0])
assert np.all(uvf.polarization_array == uv.jones_array)
assert 'Flag object with type "waterfall"' in uvf.history
assert pyuvdata_version_str in uvf.history
def test_to_antenna_flags():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf.to_waterfall()
uvf.to_flag()
uvf.flag_array[0, 10, 0] = True # Flag time0, chan10
uvf.flag_array[1, 15, 0] = True # Flag time1, chan15
uvf.to_antenna(uvc)
nt.assert_true(np.all(uvf.ant_array == uvc.ant_array))
nt.assert_true(np.all(uvf.time_array == uvc.time_array))
nt.assert_true(np.all(uvf.flag_array[:, 0, 10, 0, 0]))
nt.assert_true(np.all(uvf.flag_array[:, 0, 15, 1, 0]))
nt.assert_true(uvf.flag_array.mean() == 2. * uvc.Nants_data /
uvf.flag_array.size)
def test_init(self):
# init with no meta
AC = abscal.AbsCal(self.AC.model, self.AC.data)
assert AC.bls is None
# init with meta
AC = abscal.AbsCal(self.AC.model,
self.AC.data,
antpos=self.AC.antpos,
freqs=self.AC.freqs)
assert np.allclose(AC.bls[(24, 25, 'ee')][0], -14.607842046642745)
# init with meta
AC = abscal.AbsCal(self.AC.model, self.AC.data)
# test feeding file and refant and bl_cut and bl_taper
AC = abscal.AbsCal(self.model_fname,
self.data_fname,
refant=24,
antpos=self.AC.antpos,
max_bl_cut=26.0,
bl_taper_fwhm=15.0)
# test ref ant
assert AC.refant == 24
assert np.allclose(np.linalg.norm(AC.antpos[24]), 0.0)
# test bl cut
assert not np.any(
np.array(
list(map(lambda k: np.linalg.norm(AC.bls[k]), AC.bls.keys())))
> 26.0)
# test bl taper
assert np.median(AC.wgts[(24, 25, 'ee')]) > np.median(
AC.wgts[(24, 39, 'ee')])
# test with input cal
bl = (24, 25, 'ee')
uvc = UVCal()
uvc.read_calfits(self.input_cal)
aa = uvc.ant_array.tolist()
g = (uvc.gain_array[aa.index(bl[0])] *
uvc.gain_array[aa.index(bl[1])].conj()).squeeze().T
gf = (uvc.flag_array[aa.index(bl[0])] +
uvc.flag_array[aa.index(bl[1])]).squeeze().T
w = self.AC.wgts[bl] * ~gf
AC2 = abscal.AbsCal(copy.deepcopy(self.AC.model),
copy.deepcopy(self.AC.data),
wgts=copy.deepcopy(self.AC.wgts),
refant=24,
input_cal=self.input_cal)
np.testing.assert_array_almost_equal(self.AC.data[bl] / g * w,
AC2.data[bl] * w)
def test_to_antenna_errors():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uv = UVData()
uv.read_miriad(test_d_file)
uvf = UVFlag(test_f_file)
uvf.to_waterfall()
nt.assert_raises(ValueError, uvf.to_antenna,
7.3) # invalid matching object
uvf = UVFlag(uv)
nt.assert_raises(ValueError, uvf.to_antenna,
uvc) # Cannot pass in baseline type
uvf = UVFlag(test_f_file)
uvf.to_waterfall()
uvf.polarization_array[0] = -4
nt.assert_raises(ValueError, uvf.to_antenna, uvc) # Mismatched pols
def __init__(self,
refant=0,
n_phase_iter=5,
n_cycles=1,
min_bl_per_ant=2,
eps=1e-10,
min_ant_times=1,
spw=0,
t_avg=1):
self.model_vis = UVData()
self.measured_vis = UVData()
self.uvcal = UVCal()
self.meta_params = StefcalMeta()
self.meta_params.refant = refant
self.meta_params.n_phase_iter = n_phase_iter
self.meta_params.n_cycles = n_cycles
self.meta_params.id = str(uuid.uuid4())
self.meta_params.n_phase_iter = n_phase_iter
self.meta_params.min_bl_per_ant = min_bl_per_ant
self.meta_params.eps = eps
self.meta_params.spw = spw
self.meta_params.t_avg = t_avg
#self.meta_params.trim_neff=trim_neff
self.meta_params.min_ant_times = min_ant_times
self.cal_flag_weights = CalFlagWeights(self.meta_params.id)
def test_init_waterfall_uvc():
uv = UVCal()
uv.read_calfits(test_c_file)
uvf = UVFlag(uv, waterfall=True)
nt.assert_true(uvf.metric_array.shape == (uv.Ntimes, uv.Nfreqs, uv.Njones))
nt.assert_true(np.all(uvf.metric_array == 0))
nt.assert_true(uvf.weights_array.shape == (uv.Ntimes, uv.Nfreqs,
uv.Njones))
nt.assert_true(np.all(uvf.weights_array == 1))
nt.assert_true(uvf.type == 'waterfall')
nt.assert_true(uvf.mode == 'metric')
nt.assert_true(np.all(uvf.time_array == np.unique(uv.time_array)))
nt.assert_true(np.all(uvf.freq_array == uv.freq_array[0]))
nt.assert_true(np.all(uvf.polarization_array == uv.jones_array))
nt.assert_true('Flag object with type "waterfall"' in uvf.history)
nt.assert_true(hera_qm_version_str in uvf.history)
def test_break_read_multi():
"""Test errors for different numbers of files."""
testdir2 = os.path.join(DATA_PATH, "fhd_cal_data/set2")
obs_testfile_list = [
obs_testfile,
os.path.join(testdir2, testfile_prefix + "obs.sav"),
]
cal_testfile_list = [
cal_testfile,
os.path.join(testdir2, testfile_prefix + "cal.sav"),
]
settings_testfile_list = [
settings_testfile,
os.path.join(testdir2, testfile_prefix + "settings.txt"),
]
fhd_cal = UVCal()
pytest.raises(
ValueError,
fhd_cal.read_fhd_cal,
cal_testfile_list,
obs_testfile_list[0],
settings_file=settings_testfile_list,
)
pytest.raises(
ValueError,
fhd_cal.read_fhd_cal,
cal_testfile_list,
obs_testfile_list,
settings_file=settings_testfile_list[0],
)
pytest.raises(
ValueError,
fhd_cal.read_fhd_cal,
cal_testfile_list,
obs_testfile_list + obs_testfile_list,
settings_file=settings_testfile_list,
)
pytest.raises(
ValueError,
fhd_cal.read_fhd_cal,
cal_testfile_list,
obs_testfile_list,
settings_file=settings_testfile_list + settings_testfile_list,
)
pytest.raises(
ValueError,
fhd_cal.read_fhd_cal,
cal_testfile_list[0],
obs_testfile_list,
settings_file=settings_testfile_list[0],
)
pytest.raises(
ValueError,
fhd_cal.read_fhd_cal,
cal_testfile_list[0],
obs_testfile_list[0],
settings_file=settings_testfile_list,
)
def test_add_errors():
uv = UVData()
uv.read_miriad(test_d_file)
uvc = UVCal()
uvc.read_calfits(test_c_file)
uv1 = UVFlag(uv)
# Mismatched classes
nt.assert_raises(ValueError, uv1.__add__, 3)
# Mismatched types
uv2 = UVFlag(uvc)
nt.assert_raises(ValueError, uv1.__add__, uv2)
# Mismatched modes
uv3 = UVFlag(uv, mode='flag')
nt.assert_raises(ValueError, uv1.__add__, uv3)
# Invalid axes
nt.assert_raises(ValueError, uv1.__add__, uv1, axis='antenna')
nt.assert_raises(ValueError, uv2.__add__, uv2, axis='baseline')
def test_readwriteread(tmp_path):
"""
Omnical fits loopback test.
Read in calfits file, write out new calfits file, read back in and check for
object equality.
"""
cal_in = UVCal()
cal_out = UVCal()
testfile = os.path.join(DATA_PATH, "zen.2457698.40355.xx.gain.calfits")
write_file = str(tmp_path / "outtest_omnical.fits")
cal_in.read_calfits(testfile)
cal_in.write_calfits(write_file, clobber=True)
cal_out.read_calfits(write_file)
assert cal_in == cal_out
return
def test_readwriteread_delays():
"""
Read-Write-Read test with a fits calibration files containing delays.
Read in uvfits file, write out new uvfits file, read back in and check for
object equality
"""
cal_in = UVCal()
cal_out = UVCal()
testfile = os.path.join(DATA_PATH, 'zen.2457698.40355.xx.delay.calfits')
write_file = os.path.join(DATA_PATH, 'test/outtest_firstcal.fits')
cal_in.read_calfits(testfile)
cal_in.write_calfits(write_file, clobber=True)
cal_out.read_calfits(write_file)
assert cal_in == cal_out
del (cal_in)
del (cal_out)
gains[index90, :, poi_i, 1] = y90 gains[index150, :, poi_i, 0] = x150 gains[index150, :, poi_i, 1] = y150 gains[index230, :, poi_i, 0] = x230 gains[index230, :, poi_i, 1] = y230 gains[index320, :, poi_i, 0] = x320 gains[index320, :, poi_i, 1] = y320 gains[index400, :, poi_i, 0] = x400 gains[index400, :, poi_i, 1] = y400 gains[index524, :, poi_i, 0] = x524 gains[index524, :, poi_i, 1] = y524 datafile.close() ### cal = UVCal() cal.cal_type = 'gain' cal.set_gain() cal.Nfreqs = Nfreqs cal.Njones = Njones cal.Ntimes = Ntimes # # Change the history comment to list field, freq range name, instrument, averaging sample set, pointing JD reference, # calibration catalogs, and whatever else is important. # cal.history = 'EXAMPLE HISTORY, PLEASE CHANGE: EoR0 highband per frequency, per pointing, per polarization bandpass for MWA, averaged per cable over Season 1 using an early version of KGS. Pointing JD is referenced from Aug 23,2013.' # cal.Nspws = 1 cal.freq_array = freq_array.reshape(cal.Nspws, -1) cal.freq_range = [freq_array[0], freq_array[-1]] # valid frequencies for solutions. cal.channel_width = np.diff(freq_array)[0]
