def test_breakread_miriad(uv_in_paper, tmp_path):
"""Test Miriad file checking."""
uv_in, uv_out, testfile = uv_in_paper
with pytest.raises(IOError) as cm:
uv_in.read("foo", file_type="miriad")
assert str(cm.value).startswith("foo not found")
uv_in_copy = uv_in.copy()
uv_in_copy.Nblts += 10
uv_in_copy.write_miriad(testfile, clobber=True, run_check=False)
with uvtest.check_warnings(
UserWarning, "Nblts does not match the number of unique blts in the data"
):
uv_out.read(testfile, run_check=False)
uv_in_copy = uv_in.copy()
uv_in_copy.Nbls += 10
uv_in_copy.write_miriad(testfile, clobber=True, run_check=False)
with uvtest.check_warnings(
UserWarning, "Nbls does not match the number of unique baselines in the data"
):
uv_out.read(testfile, run_check=False)
uv_in_copy = uv_in.copy()
uv_in_copy.Ntimes += 10
uv_in_copy.write_miriad(testfile, clobber=True, run_check=False)
with uvtest.check_warnings(
UserWarning, "Ntimes does not match the number of unique times in the data"
):
uv_out.read(testfile, run_check=False)
def test_multi_unphase_on_read(casa_uvfits, tmp_path):
uv_full = casa_uvfits
uv_full2 = UVData()
testfile1 = str(tmp_path / "uv1.uvfits")
testfile2 = str(tmp_path / "uv2.uvfits")
uv1 = uv_full.copy()
uv2 = uv_full.copy()
uv1.select(freq_chans=np.arange(0, 32))
uv2.select(freq_chans=np.arange(32, 64))
uv1.write_uvfits(testfile1)
uv2.write_uvfits(testfile2)
with uvtest.check_warnings(
UserWarning,
[
"Telescope EVLA is not",
"The uvw_array does not match the expected values given the "
"antenna positions.",
"Telescope EVLA is not",
"The uvw_array does not match the expected values given the "
"antenna positions.",
"The uvw_array does not match the expected values given the "
"antenna positions.",
"The uvw_array does not match the expected values given the "
"antenna positions.",
"Unphasing this UVData object to drift",
"Unphasing other UVData object to drift",
"The uvw_array does not match the expected values given the "
"antenna positions.",
],
):
uv1.read(np.array([testfile1, testfile2]), unphase_to_drift=True)
# Check history is correct, before replacing and doing a full object check
assert uvutils._check_histories(
uv_full.history + " Downselected to "
"specific frequencies using pyuvdata. "
"Combined data along frequency axis "
"using pyuvdata.",
uv1.history,
)
uv_full.unphase_to_drift()
uv1.history = uv_full.history
assert uv1 == uv_full
# check unphasing when reading only one file
with uvtest.check_warnings(
UserWarning,
[
"Telescope EVLA is not",
"The uvw_array does not match the expected values given the "
"antenna positions.",
"Unphasing this UVData object to drift",
],
):
uv_full2.read(casa_tutorial_uvfits, unphase_to_drift=True)
assert uv_full2 == uv_full
def test_rwr_miriad_antpos_issues(uv_in_paper, tmp_path):
"""
test warnings and errors associated with antenna position issues in Miriad files
Read in Miriad PAPER file, mess with various antpos issues and write out as
a new Miriad file, read back in and check for appropriate behavior.
"""
uv_in, uv_out, write_file = uv_in_paper
uv_in_copy = uv_in.copy()
uv_in_copy.antenna_positions = None
uv_in_copy.write_miriad(write_file, clobber=True, run_check=False)
with uvtest.check_warnings(
UserWarning, "Antenna positions are not present in the file.", nwarnings=2
):
uv_out.read(write_file, run_check=False)
assert uv_in_copy == uv_out
uv_in_copy = uv_in.copy()
ants_with_data = list(set(uv_in_copy.ant_1_array).union(uv_in_copy.ant_2_array))
ant_ind = np.where(uv_in_copy.antenna_numbers == ants_with_data[0])[0]
uv_in_copy.antenna_positions[ant_ind, :] = [0, 0, 0]
uv_in_copy.write_miriad(write_file, clobber=True, no_antnums=True)
with uvtest.check_warnings(
UserWarning,
[
"antenna number",
"The uvw_array does not match the expected values given the antenna "
"positions.",
],
):
uv_out.read(write_file)
assert uv_in_copy == uv_out
uv_in.antenna_positions = None
ants_with_data = sorted(set(uv_in.ant_1_array).union(uv_in.ant_2_array))
new_nums = []
new_names = []
for a in ants_with_data:
new_nums.append(a)
ind = np.where(uv_in.antenna_numbers == a)[0][0]
new_names.append(uv_in.antenna_names[ind])
uv_in.antenna_numbers = np.array(new_nums)
uv_in.antenna_names = new_names
uv_in.Nants_telescope = len(uv_in.antenna_numbers)
uv_in.write_miriad(write_file, clobber=True, no_antnums=True, run_check=False)
with uvtest.check_warnings(
UserWarning, "Antenna positions are not present in the file.", nwarnings=2
):
uv_out.read(write_file, run_check=False)
assert uv_in == uv_out
def test_freq_range(mwa_beam_1ppd):
beam1 = mwa_beam_1ppd
beam2 = UVBeam()
# include all
beam2.read_mwa_beam(filename, pixels_per_deg=1, freq_range=[100e6, 200e6])
assert beam1 == beam2
beam2.read_mwa_beam(filename, pixels_per_deg=1, freq_range=[100e6, 150e6])
beam1.select(freq_chans=[0, 1])
assert beam1.history != beam2.history
beam1.history = beam2.history
assert beam1 == beam2
with uvtest.check_warnings(
UserWarning, match="Only one available frequency in freq_range"):
beam1.read_mwa_beam(filename,
pixels_per_deg=1,
freq_range=[100e6, 130e6])
with pytest.raises(ValueError,
match="No frequencies available in freq_range"):
beam2.read_mwa_beam(filename,
pixels_per_deg=1,
freq_range=[100e6, 110e6])
with pytest.raises(ValueError, match="freq_range must have 2 elements."):
beam2.read_mwa_beam(filename, pixels_per_deg=1, freq_range=[100e6])
def test_select_on_read():
mwa_uv = UVData()
mwa_uv2 = UVData()
mwa_uv.read_mwa_corr_fits(filelist[0:2], correct_cable_len=True)
unique_times = np.unique(mwa_uv.time_array)
select_times = unique_times[
np.where(
(unique_times >= np.min(mwa_uv.time_array))
& (unique_times <= np.mean(mwa_uv.time_array))
)
]
mwa_uv.select(times=select_times)
with uvtest.check_warnings(
UserWarning,
[
'Warning: select on read keyword set, but file_type is "mwa_corr_fits"',
"telescope_location is not set. Using known values for MWA.",
"some coarse channel files were not submitted",
],
):
mwa_uv2.read(
filelist[0:2],
correct_cable_len=True,
time_range=[np.min(mwa_uv.time_array), np.mean(mwa_uv.time_array)],
)
assert mwa_uv == mwa_uv2
def test_extra_keywords_warnings(tmp_path, hera_beam_casa):
beam_in = hera_beam_casa
testfile = str(tmp_path / "outtest_beam.fits")
# check for warnings with extra_keywords keys that are too long
beam_in.extra_keywords["test_long_key"] = True
with uvtest.check_warnings(
UserWarning,
"key test_long_key in extra_keywords is longer than 8 characters"):
beam_in.check()
with uvtest.check_warnings(
UserWarning,
"key test_long_key in extra_keywords is longer than 8 characters"):
beam_in.write_beamfits(testfile, run_check=False, clobber=True)
return
def test_extra_keywords_errors(tmp_path, hera_beam_casa, ex_val, error_msg):
beam_in = hera_beam_casa
testfile = str(tmp_path / "outtest_beam.fits")
# fill in missing parameters
beam_in.data_normalization = "peak"
beam_in.feed_name = "casa_ideal"
beam_in.feed_version = "v0"
beam_in.model_name = "casa_airy"
beam_in.model_version = "v0"
# this file is actually in an orthoslant projection RA/DEC at zenith at a
# particular time.
# For now pretend it's in a zenith orthoslant projection
beam_in.pixel_coordinate_system = "orthoslant_zenith"
# check for warnings & errors with extra_keywords that are dicts, lists or arrays
keyword = list(ex_val.keys())[0]
val = ex_val[keyword]
beam_in.extra_keywords[keyword] = val
with uvtest.check_warnings(
UserWarning,
f"{keyword} in extra_keywords is a list, array or dict"):
beam_in.check()
with pytest.raises(TypeError, match=error_msg):
beam_in.write_beamfits(testfile, run_check=False)
return
def test_read_write_read_atca(tmp_path):
uv_in = UVData()
uv_out = UVData()
atca_file = os.path.join(DATA_PATH, "atca_miriad")
testfile = str(tmp_path / "outtest_atca_miriad.uv")
with uvtest.check_warnings(
UserWarning,
[
"Altitude is not present in Miriad file, and "
"telescope ATCA is not in known_telescopes. ",
"Altitude is not present",
"Telescope location is set at sealevel at the file lat/lon "
"coordinates. Antenna positions are present, but the mean antenna "
"position does not give a telescope_location on the surface of the "
"earth. Antenna positions do not appear to be on the surface of the "
"earth and will be treated as relative.",
"Telescope ATCA is not in known_telescopes.",
"The uvw_array does not match the expected values given the antenna "
"positions.",
],
):
uv_in.read(atca_file)
uv_in.write_miriad(testfile, clobber=True)
uv_out.read(testfile)
assert uv_in == uv_out
def test_read_yaml_override(cst_efield_2freq):
pytest.importorskip("yaml")
beam1 = UVBeam()
beam2 = UVBeam()
extra_keywords = {
"software": "CST 2016",
"sim_type": "E-farfield",
"layout": "1 antenna",
"port_num": 1,
}
beam1 = cst_efield_2freq
beam1.telescope_name = "test"
with uvtest.check_warnings(
UserWarning,
match=("The telescope_name keyword is set, overriding "
"the value in the settings yaml file."),
):
beam2.read_cst_beam(cst_yaml_file,
beam_type="efield",
telescope_name="test"),
assert beam1 == beam2
assert beam2.reference_impedance == 100
assert beam2.extra_keywords == extra_keywords
def test_file_with_bad_extra_words():
"""Test file with bad extra words is iterated and popped correctly."""
fname = os.path.join(DATA_PATH, "test_miriad_changing_extra.uv")
uv = UVData()
warn_message = [
"Altitude is not present in Miriad file, "
"using known location values for PAPER.",
"Mean of empty slice.",
"invalid value encountered in double_scalars",
"npols=4 but found 1 pols in data file",
"Mean of empty slice.",
"invalid value encountered in double_scalars",
"antenna number 0 has visibilities associated with it, but it has a "
"position of (0,0,0)",
"antenna number 26 has visibilities associated with it, "
"but it has a position of (0,0,0)",
]
warn_category = (
[UserWarning]
+ [RuntimeWarning] * 2
+ [UserWarning]
+ [RuntimeWarning] * 2
+ [UserWarning] * 2
)
# This is an old PAPER file, run_check must be set to false
# The antenna positions is (0, 0, 0) vector
with uvtest.check_warnings(warn_category, warn_message):
uv.read_miriad(fname, run_check=False)
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 test_casa_nonascii_bytes_antenna_names():
"""Test that nonascii bytes in antenna names are handled properly."""
uv1 = UVData()
testfile = os.path.join(DATA_PATH,
"corrected2_zen.2458106.28114.ant012.HH.uvfits")
# this file has issues with the telescope location so turn checking off
with uvtest.check_warnings(
UserWarning, "Telescope mock-HERA is not in known_telescopes."):
uv1.read(testfile, run_check=False)
# fmt: off
expected_ant_names = [
'HH0', 'HH1', 'HH2', 'H2', 'H2', 'H2', 'H2', 'H2', 'H2', 'H2', 'H2',
'HH11', 'HH12', 'HH13', 'HH14', 'H14', 'H14', 'H14', 'H14', 'H14',
'H14', 'H14', 'H14', 'HH23', 'HH24', 'HH25', 'HH26', 'HH27', 'H27',
'H27', 'H27', 'H27', 'H27', 'H27', 'H27', 'H27', 'HH36', 'HH37',
'HH38', 'HH39', 'HH40', 'HH41', 'H41', 'H41', 'H41', 'H41', 'H41',
'H41', 'H41', 'H41', 'HH50', 'HH51', 'HH52', 'HH53', 'HH54', 'HH55',
'H55', 'H55', 'H55', 'H55', 'H55', 'H55', 'H55', 'H55', 'H55', 'HH65',
'HH66', 'HH67', 'HH68', 'HH69', 'HH70', 'HH71', 'H71', 'H71', 'H71',
'H71', 'H71', 'H71', 'H71', 'H71', 'H71', 'H71', 'HH82', 'HH83',
'HH84', 'HH85', 'HH86', 'HH87', 'HH88', 'H88', 'H88', 'H88', 'H88',
'H88', 'H88', 'H88', 'H88', 'H88', 'HH98', 'H98', 'H98', 'H98', 'H98',
'H98', 'H98', 'H98', 'H98', 'H98', 'H98', 'H98', 'H98', 'H98', 'H98',
'H98', 'H98', 'H98', 'H98', 'H98', 'H98', 'H98', 'HH120', 'HH121',
'HH122', 'HH123', 'HH124', 'H124', 'H124', 'H124', 'H124', 'H124',
'H124', 'H124', 'H124', 'H124', 'H124', 'H124', 'HH136', 'HH137',
'HH138', 'HH139', 'HH140', 'HH141', 'HH142', 'HH143'
]
# fmt: on
assert uv1.antenna_names == expected_ant_names
def test_read_fhd_warnings():
"""Test warnings with various broken inputs."""
# bad obs structure values
broken_data_file = testdir + testfile_prefix + "broken_vis_XX.sav"
bad_filelist = [
testfiles[0],
testfiles[2],
broken_data_file,
testfiles[6],
testfiles[7],
]
warn_messages = [
"Ntimes does not match",
"Telescope location derived from obs",
"Telescope foo is not in known_telescopes.",
"These visibilities may have been phased improperly",
"Nbls does not match",
]
fhd_uv = UVData()
with uvtest.check_warnings(UserWarning, warn_messages):
fhd_uv.read(bad_filelist, run_check=False)
# bad flag file
broken_flag_file = testdir + testfile_prefix + "broken_flags.sav"
bad_filelist = testfiles[1:] + [broken_flag_file]
fhd_uv = UVData()
with pytest.raises(
ValueError,
match="No recognized key for visibility weights in flags_file."):
fhd_uv.read(bad_filelist)
def test_read_power_single_freq(cst_power_1freq):
# test single frequency
beam2 = UVBeam()
beam1 = cst_power_1freq
assert beam1.freq_array == [150e6]
assert beam1.pixel_coordinate_system == "az_za"
assert beam1.beam_type == "power"
assert beam1.data_array.shape == (1, 1, 2, 1, 181, 360)
# test single frequency and not rotating the polarization
with uvtest.check_warnings(UserWarning,
"No frequency provided. Detected frequency is"):
beam2.read_cst_beam(
cst_files[0],
beam_type="power",
telescope_name="TEST",
feed_name="bob",
feed_version="0.1",
model_name="E-field pattern - Rigging height 4.9m",
model_version="1.0",
rotate_pol=False,
)
assert beam2.freq_array == [150e6]
assert beam2.pixel_coordinate_system == "az_za"
assert beam2.beam_type == "power"
assert beam2.polarization_array == np.array([-5])
assert beam2.data_array.shape == (1, 1, 1, 1, 181, 360)
assert np.allclose(beam1.data_array[:, :, 0, :, :, :], beam2.data_array)
def test_read_fhd_write_read_uvfits_no_settings(tmp_path):
"""
FHD to uvfits loopback test with no settings file.
Read in FHD files, write out as uvfits, read back in and check for object
equality.
"""
fhd_uv = UVData()
uvfits_uv = UVData()
messages = [
"No settings file included in file list",
"Telescope location derived from obs lat/lon/alt values does "
"not match the location in the layout file. Value from obs "
"lat/lon/alt matches the known_telescopes values, using them.",
"The uvw_array does not match the expected values given the antenna positions.",
]
with uvtest.check_warnings(UserWarning, messages):
fhd_uv.read(testfiles[:-2])
# Check only pyuvdata history with no settings file
assert fhd_uv.history == fhd_uv.pyuvdata_version_str
outfile = str(tmp_path / "outtest_FHD_1061316296.uvfits")
fhd_uv.write_uvfits(
outfile,
spoof_nonessential=True,
)
uvfits_uv.read_uvfits(outfile)
assert fhd_uv == uvfits_uv
def test_read_fhd_write_read_uvfits_bad_obs_loc(tmp_path):
"""
FHD to uvfits loopback test with bad obs location (and bad layout location).
Read in FHD files, write out as uvfits, read back in and check for object
equality.
"""
fhd_uv = UVData()
uvfits_uv = UVData()
bad_obs_loc_file = testdir + testfile_prefix + "bad_obs_loc_vis_XX.sav"
files_use = [
testfiles[0],
testfiles[2],
bad_obs_loc_file,
testfiles[6],
testfiles[7],
]
messages = [
"Telescope location derived from obs",
"tile_names from obs structure does not match",
"The uvw_array does not match the expected values given the antenna "
"positions.",
]
with uvtest.check_warnings(UserWarning, messages):
fhd_uv.read(files_use)
outfile = str(tmp_path / "outtest_FHD_1061316296.uvfits")
fhd_uv.write_uvfits(
outfile,
spoof_nonessential=True,
)
uvfits_uv.read_uvfits(outfile)
assert fhd_uv == uvfits_uv
def test_read_fhd_write_read_uvfits_no_layout():
"""
Test errors/warnings with with no layout file.
"""
fhd_uv = UVData()
files_use = testfiles[:-3] + [testfiles[-2]]
# check warning raised
with uvtest.check_warnings(UserWarning, "No layout file"):
fhd_uv.read(files_use, run_check=False)
with pytest.raises(
ValueError,
match="Required UVParameter _antenna_positions has not been set"):
with uvtest.check_warnings(UserWarning, "No layout file"):
fhd_uv.read(files_use)
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
with uvtest.check_warnings(
UserWarning,
"key test_long_key in extra_keywords is longer than 8 characters"):
cal_in.check()
with uvtest.check_warnings(
UserWarning,
"key test_long_key in extra_keywords is longer than 8 characters"):
cal_in.write_calfits(testfile, run_check=False, clobber=True)
return
def test_read_write_read_miriad_partial_with_warnings(uv_in_paper, tmp_path):
full, uv_out, write_file = uv_in_paper
# check partial read selections
full.write_miriad(write_file, clobber=True)
uv_in = UVData()
# check handling for generic read selections unsupported by read_miriad
unique_times = np.unique(full.time_array)
times_to_keep = unique_times[
((unique_times > 2456865.607) & (unique_times < 2456865.609))
]
with uvtest.check_warnings(
UserWarning,
[
"Warning: a select on read keyword is set",
"The uvw_array does not match the expected values given the antenna "
"positions.",
"The uvw_array does not match the expected values given the antenna "
"positions.",
],
):
uv_in.read(write_file, times=times_to_keep)
exp_uv = full.select(times=times_to_keep, inplace=False)
assert uv_in == exp_uv
uv_in = UVData()
# check handling for generic read selections unsupported by read_miriad
blts_select = np.where(full.time_array == unique_times[0])[0]
ants_keep = [0, 2, 4]
with uvtest.check_warnings(
UserWarning,
[
"Warning: blt_inds is set along with select on read",
"The uvw_array does not match the expected values given the antenna "
"positions.",
"The uvw_array does not match the expected values given the antenna "
"positions.",
],
):
uv_in.read(write_file, blt_inds=blts_select, antenna_nums=ants_keep)
exp_uv = full.select(blt_inds=blts_select, antenna_nums=ants_keep, inplace=False)
assert uv_in != exp_uv
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_readwriteread_error_single_time(tmp_path, casa_uvfits):
uv_in = casa_uvfits
uv_out = UVData()
write_file = str(tmp_path / "outtest_casa.uvfits")
write_file2 = str(tmp_path / "outtest_casa2.uvfits")
# check error if one time & no inttime specified
uv_singlet = uv_in.select(times=uv_in.time_array[0], inplace=False)
uv_singlet.write_uvfits(write_file)
with fits.open(write_file, memmap=True) as hdu_list:
hdunames = uvutils._fits_indexhdus(hdu_list)
vis_hdu = hdu_list[0]
vis_hdr = vis_hdu.header.copy()
raw_data_array = vis_hdu.data.data
par_names = np.array(vis_hdu.data.parnames)
pars_use = np.where(par_names != "INTTIM")[0]
par_names = par_names[pars_use].tolist()
group_parameter_list = [vis_hdu.data.par(name) for name in par_names]
vis_hdu = fits.GroupData(raw_data_array,
parnames=par_names,
pardata=group_parameter_list,
bitpix=-32)
vis_hdu = fits.GroupsHDU(vis_hdu)
vis_hdu.header = vis_hdr
ant_hdu = hdu_list[hdunames["AIPS AN"]]
hdulist = fits.HDUList(hdus=[vis_hdu, ant_hdu])
hdulist.writeto(write_file2, overwrite=True)
with pytest.raises(ValueError) as cm:
with uvtest.check_warnings(
[
UserWarning,
astropy._erfa.core.ErfaWarning,
astropy._erfa.core.ErfaWarning,
UserWarning,
],
[
"Telescope EVLA is not",
'ERFA function "utcut1" yielded 1 of "dubious year (Note 3)"',
'ERFA function "utctai" yielded 1 of "dubious year (Note 3)"',
"LST values stored in this file are not self-consistent",
],
):
uv_out.read(write_file2),
assert str(cm.value).startswith(
"integration time not specified and only one time present")
return
def test_read_fhd_select():
"""
test select on read with FHD files.
Read in FHD files with generic read & select on read, compare to read fhd
files then do select
"""
fhd_uv = UVData()
fhd_uv2 = UVData()
with uvtest.check_warnings(
UserWarning,
[
'Warning: select on read keyword set, but file_type is "fhd" which '
"does not support select on read. Entire file will be read and then "
"select will be performed",
"Telescope location derived from obs lat/lon/alt values does not "
"match the location in the layout file. Value from obs lat/lon/alt "
"matches the known_telescopes values, using them.",
"The uvw_array does not match the expected values given the antenna "
"positions.",
"The uvw_array does not match the expected values given the antenna "
"positions.",
],
):
fhd_uv2.read(testfiles, freq_chans=np.arange(2))
with uvtest.check_warnings(
UserWarning,
[
"Telescope location derived from obs lat/lon/alt values does not "
"match the location in the layout file. Value from obs lat/lon/alt "
"matches the known_telescopes values, using them.",
"The uvw_array does not match the expected values given the antenna "
"positions.",
],
):
fhd_uv.read(testfiles)
fhd_uv.select(freq_chans=np.arange(2))
assert fhd_uv == fhd_uv2
def test_miriad_extra_keywords_errors(
uv_in_paper, tmp_path, kwd_name, kwd_value, warnstr, errstr
):
uv_in, uv_out, testfile = uv_in_paper
uvw_warn_str = "The uvw_array does not match the expected values"
# check for warnings & errors with extra_keywords that are dicts, lists or arrays
uv_in.extra_keywords[kwd_name] = kwd_value
if warnstr is None:
warnstr_list = [uvw_warn_str]
else:
warnstr_list = [warnstr, uvw_warn_str]
with uvtest.check_warnings(UserWarning, warnstr_list):
uv_in.check()
if errstr is not None:
with pytest.raises(TypeError, match=errstr):
uv_in.write_miriad(testfile, clobber=True, run_check=False)
else:
with uvtest.check_warnings(UserWarning, warnstr):
uv_in.write_miriad(testfile, clobber=True, run_check=False)
def test_miriad_read_warning_lat_lon_corrected():
miriad_uv = UVData()
# check warning when correct_lat_lon is set to False
with uvtest.check_warnings(
UserWarning,
[
"Altitude is not present in Miriad file, using known location "
"altitude value for PAPER and lat/lon from file.",
"The uvw_array does not match the expected values given the antenna "
"positions.",
],
):
miriad_uv.read(paper_miriad_file, correct_lat_lon=False)
def test_multiple_coarse():
"""
Test two coarse channel files.
Read in MWA correlator files with two different orderings of the files
and check for object equality.
"""
order1 = [filelist[0:3]]
order2 = [filelist[0], filelist[2], filelist[1]]
mwa_uv1 = UVData()
mwa_uv2 = UVData()
messages = [
"telescope_location is not set",
"coarse channels are not contiguous for this observation",
"some coarse channel files were not submitted",
]
with uvtest.check_warnings(UserWarning, messages):
mwa_uv1.read(order1)
with uvtest.check_warnings(UserWarning, messages):
mwa_uv2.read(order2)
assert mwa_uv1 == mwa_uv2
def test_extra_keywords_errors(casa_uvfits, tmp_path, kwd_name, kwd_value,
warnstr, errstr):
uv_in = casa_uvfits
testfile = str(tmp_path / "outtest_casa.uvfits")
uvw_warn_str = "The uvw_array does not match the expected values"
# check for warnings & errors with extra_keywords that are dicts, lists or arrays
uv_in.extra_keywords[kwd_name] = kwd_value
if warnstr is None:
warnstr_list = [uvw_warn_str]
else:
warnstr_list = [warnstr, uvw_warn_str]
with uvtest.check_warnings(UserWarning, match=warnstr_list):
uv_in.check()
if errstr is not None:
with pytest.raises(TypeError, match=errstr):
uv_in.write_uvfits(testfile, run_check=False)
else:
with uvtest.check_warnings(UserWarning, match=warnstr):
uv_in.write_uvfits(testfile, run_check=False)
def test_cotter_ms():
"""Test reading in an ms made from MWA data with cotter (no dysco compression)"""
uvobj = UVData()
testfile = os.path.join(DATA_PATH, "1102865728_small.ms")
uvobj.read(testfile)
# check that a select on read works
uvobj2 = UVData()
with uvtest.check_warnings(UserWarning,
"Warning: select on read keyword set"):
uvobj2.read(testfile, freq_chans=np.arange(2))
uvobj.select(freq_chans=np.arange(2))
assert uvobj == uvobj2
del uvobj
def test_read_mwa_write_uvfits(tmp_path):
"""
MWA correlator fits to uvfits loopback test.
Read in MWA correlator files, write out as uvfits, read back in and check
for object equality.
"""
mwa_uv = UVData()
uvfits_uv = UVData()
messages = [
"telescope_location is not set",
"some coarse channel files were not submitted",
]
with uvtest.check_warnings(UserWarning, messages):
mwa_uv.read_mwa_corr_fits(
filelist[0:2], correct_cable_len=True, phase_to_pointing_center=True
)
testfile = str(tmp_path / "outtest_MWAcorr.uvfits")
mwa_uv.write_uvfits(testfile, spoof_nonessential=True)
uvfits_uv.read_uvfits(testfile)
assert mwa_uv == uvfits_uv
messages = [
"telescope_location is not set",
"some coarse channel files were not submitted",
]
with uvtest.check_warnings(UserWarning, messages):
mwa_uv.read_mwa_corr_fits(
filelist[0:2], correct_cable_len=True, phase_to_pointing_center=True
)
testfile = str(tmp_path / "outtest_MWAcorr.uvfits")
mwa_uv.write_uvfits(testfile, spoof_nonessential=True)
uvfits_uv.read_uvfits(testfile)
assert mwa_uv == uvfits_uv
def test_read_metadata_only(tmp_path):
"""Test reading an MWA corr fits file as metadata only."""
uvd = UVData()
messages = [
"telescope_location is not set",
"some coarse channel files were not submitted",
]
with uvtest.check_warnings(UserWarning, messages):
uvd.read_mwa_corr_fits(
filelist[0:2],
correct_cable_len=True,
phase_to_pointing_center=True,
read_data=False,
)
assert uvd.metadata_only
def test_readwriteread_unflagged_data_warnings(tmp_path, casa_uvfits):
uv_in = casa_uvfits
write_file = str(tmp_path / "outtest_casa.uvfits")
# check that unflagged data with nsample = 0 will cause warnings
uv_in.nsample_array[list(range(11, 22))] = 0
uv_in.flag_array[list(range(11, 22))] = False
with uvtest.check_warnings(
UserWarning,
[
"The uvw_array does not match the expected values given the antenna "
"positions",
"Some unflagged data has nsample = 0",
],
):
uv_in.write_uvfits(write_file)
return
