def test_writeread_healpix_no_corrdsys(cst_power_1freq_cut_healpix, tmp_path):
beam_in = cst_power_1freq_cut_healpix
beam_out = UVBeam()
write_file = str(tmp_path / "outtest_beam.fits")
write_file2 = str(tmp_path / "outtest_beam2.fits")
beam_in.write_beamfits(write_file, clobber=True)
# now remove coordsys but leave ctype 1
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
primary_hdr.pop("COORDSYS")
hdunames = uvutils._fits_indexhdus(fname)
hpx_hdu = fname[hdunames["HPX_INDS"]]
bandpass_hdu = fname[hdunames["BANDPARM"]]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, hpx_hdu, bandpass_hdu])
hdulist.writeto(write_file2, overwrite=True)
hdulist.close()
beam_out.read_beamfits(write_file2)
assert beam_in == beam_out
return
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_cst_write_read_fits_intensity(cst_power_1freq, tmp_path):
# set up power beam
beam_in = cst_power_1freq
beam_out = UVBeam()
write_file = str(tmp_path / "outtest_beam.fits")
write_file2 = str(tmp_path / "outtest_beam2.fits")
beam_in.write_beamfits(write_file, clobber=True)
# now replace 'power' with 'intensity' for btype
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
primary_hdr["BTYPE"] = "Intensity"
hdunames = uvutils._fits_indexhdus(fname)
bandpass_hdu = fname[hdunames["BANDPARM"]]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, bandpass_hdu])
hdulist.writeto(write_file2, overwrite=True)
hdulist.close()
beam_out.read_beamfits(write_file2)
assert beam_in == beam_out
return
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_read_cst_write_read_fits_change_freq_units(cst_power_1freq, tmp_path):
# set up power beam
beam_in = cst_power_1freq
beam_out = UVBeam()
write_file = str(tmp_path / "outtest_beam.fits")
write_file2 = str(tmp_path / "outtest_beam2.fits")
beam_in.write_beamfits(write_file, clobber=True)
# now change frequency units
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
primary_hdr["CUNIT3"] = "MHz"
primary_hdr["CRVAL3"] = primary_hdr["CRVAL3"] / 1e6
primary_hdr["CDELT3"] = primary_hdr["CRVAL3"] / 1e6
hdunames = uvutils._fits_indexhdus(fname)
bandpass_hdu = fname[hdunames["BANDPARM"]]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, bandpass_hdu])
hdulist.writeto(write_file2, overwrite=True)
hdulist.close()
beam_out.read_beamfits(write_file2)
assert beam_in == beam_out
return
def test_readwriteread_missing_info(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 missing telescope_name, timesys vs timsys spelling, xyz_telescope_frame=????
uv_in.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()
vis_hdr.pop("TELESCOP")
vis_hdu.header = vis_hdr
ant_hdu = hdu_list[hdunames["AIPS AN"]]
ant_hdr = ant_hdu.header.copy()
time_sys = ant_hdr.pop("TIMSYS")
ant_hdr["TIMESYS"] = time_sys
ant_hdr["FRAME"] = "????"
ant_hdu.header = ant_hdr
hdulist = fits.HDUList(hdus=[vis_hdu, ant_hdu])
hdulist.writeto(write_file2, overwrite=True)
uv_out.read(write_file2)
assert uv_out.telescope_name == "EVLA"
assert uv_out.timesys == time_sys
return
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_fits_header_errors_delay(tmp_path, header_dict, error_msg):
# change values for various axes in flag and total quality hdus to not
# match primary hdu
cal_in = UVCal()
cal_out = UVCal()
testfile = os.path.join(DATA_PATH, "zen.2457698.40355.xx.delay.calfits")
write_file = str(tmp_path / "outtest_firstcal.fits")
write_file2 = str(tmp_path / "outtest_firstcal2.fits")
cal_in.read_calfits(testfile)
# Create filler jones info
cal_in.jones_array = np.array([-5, -6, -7, -8])
cal_in.Njones = 4
cal_in.flag_array = np.zeros(cal_in._flag_array.expected_shape(cal_in),
dtype=bool)
cal_in.delay_array = np.ones(cal_in._delay_array.expected_shape(cal_in),
dtype=np.float64)
cal_in.quality_array = np.zeros(
cal_in._quality_array.expected_shape(cal_in))
# add total_quality_array so that can be tested as well
cal_in.total_quality_array = np.zeros(
cal_in._total_quality_array.expected_shape(cal_in))
# write file
cal_in.write_calfits(write_file, clobber=True)
unit = list(header_dict.keys())[0]
keyword = header_dict[unit]
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
hdunames = uvutils._fits_indexhdus(fname)
ant_hdu = fname[hdunames["ANTENNAS"]]
flag_hdu = fname[hdunames["FLAGS"]]
flag_hdr = flag_hdu.header
totqualhdu = fname[hdunames["TOTQLTY"]]
totqualhdr = totqualhdu.header
if unit == "flag":
flag_hdr[keyword] *= 2
elif unit == "totqual":
totqualhdr[keyword] *= 2
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)
totqualhdu = fits.ImageHDU(data=totqualhdu.data, header=totqualhdr)
hdulist.append(totqualhdu)
hdulist.writeto(write_file2, overwrite=True)
hdulist.close()
with pytest.raises(ValueError, match=error_msg):
cal_out.read_calfits(write_file2)
return
def test_basisvec_hdu_errors(cst_efield_1freq, tmp_path, header_dict,
error_msg):
beam_in = cst_efield_1freq
beam_out = UVBeam()
write_file = str(tmp_path / "outtest_beam.fits")
write_file2 = str(tmp_path / "outtest_beam2.fits")
# now change values for various items in basisvec hdu to not match primary hdu
beam_in.write_beamfits(write_file, clobber=True)
keyword = list(header_dict.keys())[0]
# hacky treatment of CDELT b/c we need the object to be defined already
if keyword == "CDELT1":
new_val = np.diff(beam_in.axis1_array)[0] * 2
elif keyword == "CDELT2":
new_val = np.diff(beam_in.axis2_array)[0] * 2
else:
new_val = header_dict[keyword]
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
hdunames = uvutils._fits_indexhdus(fname)
basisvec_hdu = fname[hdunames["BASISVEC"]]
basisvec_hdr = basisvec_hdu.header
basisvec_data = basisvec_hdu.data
bandpass_hdu = fname[hdunames["BANDPARM"]]
if "NAXIS" in keyword:
ax_num = keyword.split("NAXIS")[1]
if ax_num != "":
ax_num = int(ax_num)
ax_use = len(basisvec_data.shape) - ax_num
new_arrays = np.split(basisvec_data,
basisvec_hdr[keyword],
axis=ax_use)
basisvec_data = new_arrays[0]
else:
basisvec_data = np.split(
basisvec_data,
basisvec_hdr["NAXIS1"],
axis=len(basisvec_data.shape) - 1,
)[0]
else:
basisvec_hdr[keyword] = new_val
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
basisvec_hdu = fits.ImageHDU(data=basisvec_data, header=basisvec_hdr)
hdulist = fits.HDUList([prihdu, basisvec_hdu, bandpass_hdu])
hdulist.writeto(write_file2, overwrite=True)
hdulist.close()
with pytest.raises(ValueError, match=error_msg):
beam_out.read_beamfits(write_file2)
return
def test_writeread_healpix(cst_efield_1freq_cut_healpix, tmp_path):
beam_in = cst_efield_1freq_cut_healpix.copy()
beam_out = UVBeam()
write_file = str(tmp_path / "outtest_beam_hpx.fits")
beam_in.write_beamfits(write_file, clobber=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# redo for power beam
del beam_in
beam_in = cst_efield_1freq_cut_healpix
beam_in.efield_to_power()
# add optional parameters for testing purposes
beam_in.extra_keywords = {"KEY1": "test_keyword"}
beam_in.x_orientation = "east"
beam_in.reference_impedance = 340.0
beam_in.receiver_temperature_array = np.random.normal(
50.0, 5, size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.loss_array = np.random.normal(50.0,
5,
size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.mismatch_array = np.random.normal(0.0,
1.0,
size=(beam_in.Nspws,
beam_in.Nfreqs))
beam_in.s_parameters = np.random.normal(0.0,
0.3,
size=(4, beam_in.Nspws,
beam_in.Nfreqs))
# check that data_array is complex
assert np.iscomplexobj(np.real_if_close(beam_in.data_array, tol=10))
beam_in.write_beamfits(write_file, clobber=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# now remove coordsys but leave ctype 1
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
primary_hdr.pop("COORDSYS")
hdunames = uvutils._fits_indexhdus(fname)
hpx_hdu = fname[hdunames["HPX_INDS"]]
bandpass_hdu = fname[hdunames["BANDPARM"]]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, hpx_hdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
def test_multisource_error(tmp_path):
# make a file with multiple sources to test error condition
uv_in = UVData()
testfile = os.path.join(DATA_PATH,
"day2_TDEM0003_10s_norx_1src_1spw.uvfits")
write_file = str(tmp_path / "outtest_casa.uvfits")
uv_in.read(testfile)
uv_in.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 = vis_hdu.data.parnames
group_parameter_list = []
lst_ind = 0
for index, name in enumerate(par_names):
par_value = vis_hdu.data.par(name)
# lst_array needs to be split in 2 parts to get high enough accuracy
if name.lower() == "lst":
if lst_ind == 0:
# first lst entry, par_value has full lst value
# (astropy adds the 2 values)
lst_array_1 = np.float32(par_value)
lst_array_2 = np.float32(par_value -
np.float64(lst_array_1))
par_value = lst_array_1
lst_ind = 1
else:
par_value = lst_array_2
# need to account for PZERO values
group_parameter_list.append(par_value -
vis_hdr["PZERO" + str(index + 1)])
par_names.append("SOURCE")
source_array = np.ones_like(vis_hdu.data.par("BASELINE"))
mid_index = source_array.shape[0] // 2
source_array[mid_index:] = source_array[mid_index:] * 2
group_parameter_list.append(source_array)
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_file, overwrite=True)
with pytest.raises(ValueError) as cm:
uv_in.read(write_file)
assert str(cm.value).startswith("This file has multiple sources")
def test_select_read_nospw_pol(casa_uvfits, tmp_path):
# this requires writing a new file because the no spw file we have has only 1 pol
with fits.open(casa_tutorial_uvfits, 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
raw_data_array = raw_data_array[:, :, :, 0, :, :, :]
vis_hdr["NAXIS"] = 6
vis_hdr["NAXIS5"] = vis_hdr["NAXIS6"]
vis_hdr["CTYPE5"] = vis_hdr["CTYPE6"]
vis_hdr["CRVAL5"] = vis_hdr["CRVAL6"]
vis_hdr["CDELT5"] = vis_hdr["CDELT6"]
vis_hdr["CRPIX5"] = vis_hdr["CRPIX6"]
vis_hdr["CROTA5"] = vis_hdr["CROTA6"]
vis_hdr["NAXIS6"] = vis_hdr["NAXIS7"]
vis_hdr["CTYPE6"] = vis_hdr["CTYPE7"]
vis_hdr["CRVAL6"] = vis_hdr["CRVAL7"]
vis_hdr["CDELT6"] = vis_hdr["CDELT7"]
vis_hdr["CRPIX6"] = vis_hdr["CRPIX7"]
vis_hdr["CROTA6"] = vis_hdr["CROTA7"]
vis_hdr.pop("NAXIS7")
vis_hdr.pop("CTYPE7")
vis_hdr.pop("CRVAL7")
vis_hdr.pop("CDELT7")
vis_hdr.pop("CRPIX7")
vis_hdr.pop("CROTA7")
par_names = vis_hdu.data.parnames
group_parameter_list = [
vis_hdu.data.par(ind) for ind in range(len(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"]]
write_file = str(tmp_path / "outtest_casa.uvfits")
hdulist = fits.HDUList(hdus=[vis_hdu, ant_hdu])
hdulist.writeto(write_file, overwrite=True)
pols_to_keep = [-1, -2]
uvfits_uv = UVData()
uvfits_uv.read(write_file, polarizations=pols_to_keep)
uvfits_uv2 = casa_uvfits
uvfits_uv2.select(polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
def test_source_group_params():
# make a file with a single source to test that it works
uv_in = UVData()
testfile = os.path.join(DATA_PATH,
'day2_TDEM0003_10s_norx_1src_1spw.uvfits')
write_file = os.path.join(DATA_PATH, 'test/outtest_casa.uvfits')
uvtest.checkWarnings(uv_in.read, [testfile],
message='Telescope EVLA is not')
uv_in.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 = vis_hdu.data.parnames
group_parameter_list = []
lst_ind = 0
for index, name in enumerate(par_names):
par_value = vis_hdu.data.par(name)
# lst_array needs to be split in 2 parts to get high enough accuracy
if name.lower() == 'lst':
if lst_ind == 0:
# first lst entry, par_value has full lst value (astropy adds the 2 values)
lst_array_1 = np.float32(par_value)
lst_array_2 = np.float32(par_value -
np.float64(lst_array_1))
par_value = lst_array_1
lst_ind = 1
else:
par_value = lst_array_2
# need to account for PZERO values
group_parameter_list.append(par_value -
vis_hdr['PZERO' + str(index + 1)])
par_names.append('SOURCE')
source_array = np.ones_like(vis_hdu.data.par('BASELINE'))
group_parameter_list.append(source_array)
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_file, overwrite=True)
uv_out = UVData()
uvtest.checkWarnings(uv_out.read, [write_file],
message='Telescope EVLA is not')
assert uv_in == uv_out
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:
uvtest.checkWarnings(
uv_out.read,
func_args=[write_file2],
message=[
"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",
],
nwarnings=4,
category=[
UserWarning,
astropy._erfa.core.ErfaWarning,
astropy._erfa.core.ErfaWarning,
UserWarning,
],
)
assert str(cm.value).startswith(
"integration time not specified and only one time present")
return
def test_source_group_params(casa_uvfits, tmp_path):
# make a file with a single source to test that it works
uv_in = casa_uvfits
write_file = str(tmp_path / "outtest_casa.uvfits")
write_file2 = str(tmp_path / "outtest_casa2.uvfits")
uv_in.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 = vis_hdu.data.parnames
group_parameter_list = []
lst_ind = 0
for index, name in enumerate(par_names):
par_value = vis_hdu.data.par(name)
# lst_array needs to be split in 2 parts to get high enough accuracy
if name.lower() == "lst":
if lst_ind == 0:
# first lst entry, par_value has full lst value
# (astropy adds the 2 values)
lst_array_1 = np.float32(par_value)
lst_array_2 = np.float32(par_value -
np.float64(lst_array_1))
par_value = lst_array_1
lst_ind = 1
else:
par_value = lst_array_2
# need to account for PZERO values
group_parameter_list.append(par_value -
vis_hdr["PZERO" + str(index + 1)])
par_names.append("SOURCE")
source_array = np.ones_like(vis_hdu.data.par("BASELINE"))
group_parameter_list.append(source_array)
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)
hdulist.close()
uv_out = UVData()
uv_out.read(write_file2)
assert uv_in == uv_out
def test_read_oldcalfits_delay_nofreqaxis():
"""
Test for proper behavior with old calfits delay-style files that have no freq axis.
"""
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)
# add total_quality_array so that can be tested as well
cal_in.total_quality_array = np.zeros(
cal_in._total_quality_array.expected_shape(cal_in))
# now read in the file and remove the freq axis to emulate old calfits files
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
totqualhdu = F[hdunames['TOTQLTY']]
totqualhdr = totqualhdu.header
axis_keyword_base = ['CTYPE', 'CUNIT', 'CRPIX', 'CRVAL', 'CDELT']
for keyword in axis_keyword_base:
primary_hdr.pop(keyword + '4')
# need to renumber spw & antenna indices
for keyword in axis_keyword_base:
primary_hdr[keyword + '4'] = primary_hdr.pop(keyword + '5')
primary_hdr[keyword + '5'] = primary_hdr.pop(keyword + '6')
data = data[:, :, 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)
totqualhdu = fits.ImageHDU(data=totqualhdu.data, header=totqualhdr)
hdulist.append(totqualhdu)
hdulist.writeto(write_file, overwrite=True)
message = write_file + ' appears to be an old calfits format'
uvtest.checkWarnings(cal_out.read_calfits, [write_file],
message=message,
category=DeprecationWarning)
assert cal_in == cal_out
def test_healpix_basisvec_hdu_errors(cst_efield_1freq_cut_healpix, tmp_path,
header_dict, error_msg):
beam_in = cst_efield_1freq_cut_healpix
beam_out = UVBeam()
write_file = str(tmp_path / "outtest_beam_hpx.fits")
write_file2 = str(tmp_path / "outtest_beam_hpx2.fits")
beam_in.write_beamfits(write_file, clobber=True)
# now change values for various items in basisvec hdu to not match primary hdu
keyword = list(header_dict.keys())[0]
new_val = header_dict[keyword]
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
hdunames = uvutils._fits_indexhdus(fname)
basisvec_hdu = fname[hdunames["BASISVEC"]]
basisvec_hdr = basisvec_hdu.header
basisvec_data = basisvec_hdu.data
hpx_hdu = fname[hdunames["HPX_INDS"]]
bandpass_hdu = fname[hdunames["BANDPARM"]]
if "NAXIS" in keyword:
ax_num = keyword.split("NAXIS")[1]
if ax_num != "":
ax_num = int(ax_num)
ax_use = len(basisvec_data.shape) - ax_num
new_arrays = np.split(basisvec_data,
basisvec_hdr[keyword],
axis=ax_use)
basisvec_data = new_arrays[0]
else:
basisvec_data = np.split(
basisvec_data,
basisvec_hdr["NAXIS1"],
axis=len(basisvec_data.shape) - 1,
)[0]
else:
basisvec_hdr[keyword] = new_val
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
basisvec_hdu = fits.ImageHDU(data=basisvec_data, header=basisvec_hdr)
hdulist = fits.HDUList([prihdu, basisvec_hdu, hpx_hdu, bandpass_hdu])
hdulist.writeto(write_file2, overwrite=True)
hdulist.close()
with pytest.raises(ValueError, match=error_msg):
beam_out.read_beamfits(write_file2)
return
def test_errors():
"""
Test for various errors.
"""
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.set_unknown_cal_type()
pytest.raises(ValueError,
cal_in.write_calfits,
write_file,
run_check=False,
clobber=True)
# change values for various axes in flag and total quality hdus to not match primary hdu
cal_in.read_calfits(testfile)
# Create filler jones info
cal_in.jones_array = np.array([-5, -6, -7, -8])
cal_in.Njones = 4
cal_in.flag_array = np.zeros(cal_in._flag_array.expected_shape(cal_in),
dtype=bool)
cal_in.delay_array = np.ones(cal_in._delay_array.expected_shape(cal_in),
dtype=np.float64)
cal_in.quality_array = np.zeros(
cal_in._quality_array.expected_shape(cal_in))
# add total_quality_array so that can be tested as well
cal_in.total_quality_array = np.zeros(
cal_in._total_quality_array.expected_shape(cal_in))
header_vals_to_double = [{
'flag': 'CDELT2'
}, {
'flag': 'CDELT3'
}, {
'flag': 'CRVAL5'
}, {
'totqual': 'CDELT1'
}, {
'totqual': 'CDELT2'
}, {
'totqual': 'CRVAL4'
}]
for i, hdr_dict in enumerate(header_vals_to_double):
cal_in.write_calfits(write_file, clobber=True)
unit = list(hdr_dict.keys())[0]
keyword = hdr_dict[unit]
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
totqualhdu = F[hdunames['TOTQLTY']]
totqualhdr = totqualhdu.header
if unit == 'flag':
flag_hdr[keyword] *= 2
elif unit == 'totqual':
totqualhdr[keyword] *= 2
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)
totqualhdu = fits.ImageHDU(data=totqualhdu.data, header=totqualhdr)
hdulist.append(totqualhdu)
hdulist.writeto(write_file, overwrite=True)
pytest.raises(ValueError,
cal_out.read_calfits,
write_file,
strict_fits=True)
# repeat for gain type file
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)
# Create filler jones info
cal_in.jones_array = np.array([-5, -6, -7, -8])
cal_in.Njones = 4
cal_in.flag_array = np.zeros(cal_in._flag_array.expected_shape(cal_in),
dtype=bool)
cal_in.gain_array = np.ones(cal_in._gain_array.expected_shape(cal_in),
dtype=np.complex64)
cal_in.quality_array = np.zeros(
cal_in._quality_array.expected_shape(cal_in))
# add total_quality_array so that can be tested as well
cal_in.total_quality_array = np.zeros(
cal_in._total_quality_array.expected_shape(cal_in))
header_vals_to_double = [{
'totqual': 'CDELT1'
}, {
'totqual': 'CDELT2'
}, {
'totqual': 'CDELT3'
}, {
'totqual': 'CRVAL4'
}]
for i, hdr_dict in enumerate(header_vals_to_double):
cal_in.write_calfits(write_file, clobber=True)
unit = list(hdr_dict.keys())[0]
keyword = hdr_dict[unit]
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
hdunames = uvutils._fits_indexhdus(F)
ant_hdu = F[hdunames['ANTENNAS']]
totqualhdu = F[hdunames['TOTQLTY']]
totqualhdr = totqualhdu.header
if unit == 'totqual':
totqualhdr[keyword] *= 2
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, ant_hdu])
totqualhdu = fits.ImageHDU(data=totqualhdu.data, header=totqualhdr)
hdulist.append(totqualhdu)
hdulist.writeto(write_file, overwrite=True)
pytest.raises(ValueError,
cal_out.read_calfits,
write_file,
strict_fits=True)
def test_read_oldcalfits_delay():
"""
Test for proper behavior with old calfits delay-style files.
"""
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)
# add total_quality_array so that can be tested as well
cal_in.total_quality_array = np.zeros(
cal_in._total_quality_array.expected_shape(cal_in))
# now read in the file and remove various CRPIX and CRVAL keywords to
# emulate old calfits files
header_vals_to_remove = [{
'primary': 'CRVAL5'
}, {
'flag': 'CRVAL5'
}, {
'flag': 'CRPIX4'
}, {
'totqual': 'CRVAL4'
}, {
'primary': 'CALSTYLE'
}]
messages = [write_file, 'This file', 'This file', write_file, write_file]
messages = [m + ' appears to be an old calfits format' for m in messages]
for i, hdr_dict in enumerate(header_vals_to_remove):
cal_in.write_calfits(write_file, clobber=True)
unit = list(hdr_dict.keys())[0]
keyword = hdr_dict[unit]
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
totqualhdu = F[hdunames['TOTQLTY']]
totqualhdr = totqualhdu.header
if unit == 'primary':
primary_hdr.pop(keyword)
elif unit == 'flag':
flag_hdr.pop(keyword)
elif unit == 'totqual':
totqualhdr.pop(keyword)
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)
totqualhdu = fits.ImageHDU(data=totqualhdu.data, header=totqualhdr)
hdulist.append(totqualhdu)
hdulist.writeto(write_file, overwrite=True)
uvtest.checkWarnings(cal_out.read_calfits, [write_file],
message=messages[i],
category=DeprecationWarning)
assert cal_in == cal_out
if keyword.startswith('CR'):
pytest.raises(KeyError,
cal_out.read_calfits,
write_file,
strict_fits=True)
def test_healpix_errors():
beam_in = UVBeam()
beam_out = UVBeam()
write_file = os.path.join(DATA_PATH, 'test/outtest_beam_hpx.fits')
# now change values for various items in primary hdu to test errors
beam_in.read_cst_beam(cst_files[0],
beam_type='efield',
frequency=150e6,
telescope_name='TEST',
feed_name='bob',
feed_version='0.1',
feed_pol=['x'],
model_name='E-field pattern - Rigging height 4.9m',
model_version='1.0')
beam_in.interpolation_function = 'az_za_simple'
beam_in.to_healpix()
header_vals_to_change = [{'CTYPE1': 'foo'}, {'NAXIS1': ''}]
for i, hdr_dict in enumerate(header_vals_to_change):
beam_in.write_beamfits(write_file, clobber=True)
keyword = list(hdr_dict.keys())[0]
new_val = hdr_dict[keyword]
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
hdunames = uvutils._fits_indexhdus(F)
basisvec_hdu = F[hdunames['BASISVEC']]
hpx_hdu = F[hdunames['HPX_INDS']]
bandpass_hdu = F[hdunames['BANDPARM']]
if 'NAXIS' in keyword:
ax_num = keyword.split('NAXIS')[1]
if ax_num != '':
ax_num = int(ax_num)
ax_use = len(data.shape) - ax_num
new_arrays = np.split(data, primary_hdr[keyword], axis=ax_use)
data = new_arrays[0]
else:
data = np.squeeze(
np.split(data,
primary_hdr['NAXIS1'],
axis=len(data.shape) - 1)[0])
else:
primary_hdr[keyword] = new_val
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, basisvec_hdu, hpx_hdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
pytest.raises(ValueError, beam_out.read_beamfits, write_file)
# now change values for various items in basisvec hdu to not match primary hdu
beam_in.read_cst_beam(cst_files[0],
beam_type='efield',
frequency=150e6,
telescope_name='TEST',
feed_name='bob',
feed_version='0.1',
feed_pol=['x'],
model_name='E-field pattern - Rigging height 4.9m',
model_version='1.0')
beam_in.interpolation_function = 'az_za_simple'
beam_in.to_healpix()
header_vals_to_change = [{'CTYPE1': 'foo'}, {'NAXIS1': ''}]
for i, hdr_dict in enumerate(header_vals_to_change):
beam_in.write_beamfits(write_file, clobber=True)
keyword = list(hdr_dict.keys())[0]
new_val = hdr_dict[keyword]
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
hdunames = uvutils._fits_indexhdus(F)
basisvec_hdu = F[hdunames['BASISVEC']]
basisvec_hdr = basisvec_hdu.header
basisvec_data = basisvec_hdu.data
hpx_hdu = F[hdunames['HPX_INDS']]
bandpass_hdu = F[hdunames['BANDPARM']]
if 'NAXIS' in keyword:
ax_num = keyword.split('NAXIS')[1]
if ax_num != '':
ax_num = int(ax_num)
ax_use = len(basisvec_data.shape) - ax_num
new_arrays = np.split(basisvec_data,
basisvec_hdr[keyword],
axis=ax_use)
basisvec_data = new_arrays[0]
else:
basisvec_data = np.split(basisvec_data,
basisvec_hdr['NAXIS1'],
axis=len(basisvec_data.shape) - 1)[0]
else:
basisvec_hdr[keyword] = new_val
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
basisvec_hdu = fits.ImageHDU(data=basisvec_data, header=basisvec_hdr)
hdulist = fits.HDUList([prihdu, basisvec_hdu, hpx_hdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
pytest.raises(ValueError, beam_out.read_beamfits, write_file)
def test_readCST_writereadFITS():
beam_in = UVBeam()
beam_out = UVBeam()
beam_in.read_cst_beam(cst_files[0],
beam_type='efield',
frequency=150e6,
telescope_name='TEST',
feed_name='bob',
feed_version='0.1',
feed_pol=['x'],
model_name='E-field pattern - Rigging height 4.9m',
model_version='1.0')
# add optional parameters for testing purposes
beam_in.extra_keywords = {'KEY1': 'test_keyword'}
beam_in.x_orientation = 'east'
beam_in.reference_impedance = 340.
beam_in.receiver_temperature_array = np.random.normal(
50.0, 5, size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.loss_array = np.random.normal(50.0,
5,
size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.mismatch_array = np.random.normal(0.0,
1.0,
size=(beam_in.Nspws,
beam_in.Nfreqs))
beam_in.s_parameters = np.random.normal(0.0,
0.3,
size=(4, beam_in.Nspws,
beam_in.Nfreqs))
beam_in.interpolation_function = 'az_za_simple'
beam_in.freq_interp_kind = 'linear'
write_file = os.path.join(DATA_PATH, 'test/outtest_beam.fits')
beam_in.write_beamfits(write_file, clobber=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# redo for power beam
del (beam_in)
beam_in = UVBeam()
# read in efield and convert to power to test cross-pols
beam_in.read_cst_beam(cst_files[0],
beam_type='efield',
frequency=150e6,
telescope_name='TEST',
feed_name='bob',
feed_version='0.1',
feed_pol=['x'],
model_name='E-field pattern - Rigging height 4.9m',
model_version='1.0')
beam_in.efield_to_power()
# add optional parameters for testing purposes
beam_in.extra_keywords = {'KEY1': 'test_keyword'}
beam_in.x_orientation = 'east'
beam_in.reference_impedance = 340.
beam_in.receiver_temperature_array = np.random.normal(
50.0, 5, size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.loss_array = np.random.normal(50.0,
5,
size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.mismatch_array = np.random.normal(0.0,
1.0,
size=(beam_in.Nspws,
beam_in.Nfreqs))
beam_in.s_parameters = np.random.normal(0.0,
0.3,
size=(4, beam_in.Nspws,
beam_in.Nfreqs))
beam_in.write_beamfits(write_file, clobber=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# now replace 'power' with 'intensity' for btype
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
primary_hdr['BTYPE'] = 'Intensity'
hdunames = uvutils._fits_indexhdus(F)
bandpass_hdu = F[hdunames['BANDPARM']]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# now remove coordsys but leave ctypes 1 & 2
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
primary_hdr.pop('COORDSYS')
hdunames = uvutils._fits_indexhdus(F)
bandpass_hdu = F[hdunames['BANDPARM']]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# now change frequency units
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
primary_hdr['CUNIT3'] = 'MHz'
primary_hdr['CRVAL3'] = primary_hdr['CRVAL3'] / 1e6
primary_hdr['CDELT3'] = primary_hdr['CRVAL3'] / 1e6
hdunames = uvutils._fits_indexhdus(F)
bandpass_hdu = F[hdunames['BANDPARM']]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
def test_writeread_healpix():
beam_in = UVBeam()
beam_out = UVBeam()
# fill UVBeam object with dummy data for now for testing purposes
beam_in.read_cst_beam(cst_files[0],
beam_type='efield',
frequency=150e6,
telescope_name='TEST',
feed_name='bob',
feed_version='0.1',
feed_pol=['x'],
model_name='E-field pattern - Rigging height 4.9m',
model_version='1.0')
beam_in.interpolation_function = 'az_za_simple'
beam_in.to_healpix()
write_file = os.path.join(DATA_PATH, 'test/outtest_beam_hpx.fits')
beam_in.write_beamfits(write_file, clobber=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# redo for power beam
del (beam_in)
beam_in = UVBeam()
# read in efield and convert to power to test cross-pols
beam_in.read_cst_beam(cst_files[0],
beam_type='efield',
frequency=150e6,
telescope_name='TEST',
feed_name='bob',
feed_version='0.1',
feed_pol=['x'],
model_name='E-field pattern - Rigging height 4.9m',
model_version='1.0')
beam_in.efield_to_power()
# add optional parameters for testing purposes
beam_in.extra_keywords = {'KEY1': 'test_keyword'}
beam_in.x_orientation = 'east'
beam_in.reference_impedance = 340.
beam_in.receiver_temperature_array = np.random.normal(
50.0, 5, size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.loss_array = np.random.normal(50.0,
5,
size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.mismatch_array = np.random.normal(0.0,
1.0,
size=(beam_in.Nspws,
beam_in.Nfreqs))
beam_in.s_parameters = np.random.normal(0.0,
0.3,
size=(4, beam_in.Nspws,
beam_in.Nfreqs))
# check that data_array is complex
assert np.iscomplexobj(np.real_if_close(beam_in.data_array, tol=10))
beam_in.interpolation_function = 'az_za_simple'
beam_in.to_healpix()
# check that data_array is complex after interpolation
assert np.iscomplexobj(np.real_if_close(beam_in.data_array, tol=10))
beam_in.write_beamfits(write_file, clobber=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# now remove coordsys but leave ctype 1
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
primary_hdr.pop('COORDSYS')
hdunames = uvutils._fits_indexhdus(F)
hpx_hdu = F[hdunames['HPX_INDS']]
bandpass_hdu = F[hdunames['BANDPARM']]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, hpx_hdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
def test_readwriteread():
"""
CASA tutorial uvfits loopback test.
Read in uvfits file, write out new uvfits file, read back in and check for
object equality.
"""
uv_in = UVData()
uv_out = UVData()
testfile = os.path.join(DATA_PATH,
'day2_TDEM0003_10s_norx_1src_1spw.uvfits')
write_file = os.path.join(DATA_PATH, 'test/outtest_casa.uvfits')
uvtest.checkWarnings(uv_in.read, [testfile],
message='Telescope EVLA is not')
uv_in.write_uvfits(write_file)
uvtest.checkWarnings(uv_out.read, [write_file],
message='Telescope EVLA is not')
assert uv_in == uv_out
# test that it works with write_lst = False
uv_in.write_uvfits(write_file, write_lst=False)
uvtest.checkWarnings(uv_out.read, [write_file],
message='Telescope EVLA is not')
assert uv_in == uv_out
# check that if x_orientation is set, it's read back out properly
uv_in.x_orientation = 'east'
uv_in.write_uvfits(write_file)
uvtest.checkWarnings(uv_out.read, [write_file],
message='Telescope EVLA is not')
assert uv_in == uv_out
# check that if antenna_diameters is set, it's read back out properly
uvtest.checkWarnings(uv_in.read, [testfile],
message='Telescope EVLA is not')
uv_in.antenna_diameters = np.zeros(
(uv_in.Nants_telescope, ), dtype=np.float) + 14.0
uv_in.write_uvfits(write_file)
uvtest.checkWarnings(uv_out.read, [write_file],
message='Telescope EVLA is not')
assert uv_in == uv_out
# check that if antenna_numbers are > 256 everything works
uvtest.checkWarnings(uv_in.read, [testfile],
message='Telescope EVLA is not')
uv_in.antenna_numbers = uv_in.antenna_numbers + 256
uv_in.ant_1_array = uv_in.ant_1_array + 256
uv_in.ant_2_array = uv_in.ant_2_array + 256
uv_in.baseline_array = uv_in.antnums_to_baseline(uv_in.ant_1_array,
uv_in.ant_2_array)
uvtest.checkWarnings(
uv_in.write_uvfits, [write_file],
message='antnums_to_baseline: found > 256 antennas, using 2048 baseline'
)
uvtest.checkWarnings(uv_out.read, [write_file],
message='Telescope EVLA is not')
assert uv_in == uv_out
# check missing telescope_name, timesys vs timsys spelling, xyz_telescope_frame=????
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()
vis_hdr.pop('TELESCOP')
vis_hdu.header = vis_hdr
ant_hdu = hdu_list[hdunames['AIPS AN']]
ant_hdr = ant_hdu.header.copy()
time_sys = ant_hdr.pop('TIMSYS')
ant_hdr['TIMESYS'] = time_sys
ant_hdr['FRAME'] = '????'
ant_hdu.header = ant_hdr
hdulist = fits.HDUList(hdus=[vis_hdu, ant_hdu])
hdulist.writeto(write_file, overwrite=True)
uvtest.checkWarnings(uv_out.read, [write_file],
message='Telescope EVLA is not')
assert uv_out.telescope_name == 'EVLA'
assert uv_out.timesys == time_sys
# check error if timesys is 'IAT'
uvtest.checkWarnings(uv_in.read, [testfile],
message='Telescope EVLA is not')
uv_in.timesys = 'IAT'
pytest.raises(ValueError, uv_in.write_uvfits, write_file)
uv_in.timesys = 'UTC'
# 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_file, overwrite=True)
uvtest.checkWarnings(
pytest.raises, [ValueError, uv_out.read, write_file],
message=[
'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'
],
nwarnings=4,
category=[
UserWarning, astropy._erfa.core.ErfaWarning,
astropy._erfa.core.ErfaWarning, UserWarning
])
# 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
uvtest.checkWarnings(uv_in.write_uvfits, [write_file],
message='Some unflagged data has nsample = 0')
del (uv_in)
del (uv_out)
def test_errors():
beam_in = UVBeam()
beam_out = UVBeam()
beam_in.read_cst_beam(cst_files[0],
beam_type='efield',
frequency=150e6,
telescope_name='TEST',
feed_name='bob',
feed_version='0.1',
feed_pol=['x'],
model_name='E-field pattern - Rigging height 4.9m',
model_version='1.0')
beam_in.beam_type = 'foo'
write_file = os.path.join(DATA_PATH, 'test/outtest_beam.fits')
nt.assert_raises(ValueError,
beam_in.write_beamfits,
write_file,
clobber=True)
nt.assert_raises(ValueError,
beam_in.write_beamfits,
write_file,
clobber=True,
run_check=False)
beam_in.beam_type = 'efield'
beam_in.antenna_type = 'phased_array'
write_file = os.path.join(DATA_PATH, 'test/outtest_beam.fits')
nt.assert_raises(ValueError,
beam_in.write_beamfits,
write_file,
clobber=True)
# now change values for various items in primary hdu to test errors
beam_in.antenna_type = 'simple'
header_vals_to_change = [{
'BTYPE': 'foo'
}, {
'COORDSYS': 'orthoslant_zenith'
}, {
'NAXIS': ''
}, {
'CUNIT1': 'foo'
}, {
'CUNIT2': 'foo'
}, {
'CUNIT3': 'foo'
}]
for i, hdr_dict in enumerate(header_vals_to_change):
beam_in.write_beamfits(write_file, clobber=True)
keyword = list(hdr_dict.keys())[0]
new_val = hdr_dict[keyword]
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
hdunames = uvutils._fits_indexhdus(F)
basisvec_hdu = F[hdunames['BASISVEC']]
bandpass_hdu = F[hdunames['BANDPARM']]
if 'NAXIS' in keyword:
ax_num = keyword.split('NAXIS')[1]
if ax_num != '':
ax_num = int(ax_num)
ax_use = len(data.shape) - ax_num
new_arrays = np.split(data, primary_hdr[keyword], axis=ax_use)
data = new_arrays[0]
else:
data = np.squeeze(
np.split(data,
primary_hdr['NAXIS1'],
axis=len(data.shape) - 1)[0])
else:
primary_hdr[keyword] = new_val
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, basisvec_hdu, bandpass_hdu])
if float(astropy.__version__[0:3]) < 1.3:
hdulist.writeto(write_file, clobber=True)
else:
hdulist.writeto(write_file, overwrite=True)
nt.assert_raises(ValueError, beam_out.read_beamfits, write_file)
# now change values for various items in basisvec hdu to not match primary hdu
header_vals_to_change = [{
'COORDSYS': 'foo'
}, {
'CTYPE1': 'foo'
}, {
'CTYPE2': 'foo'
}, {
'CDELT1': np.diff(beam_in.axis1_array)[0] * 2
}, {
'CDELT2': np.diff(beam_in.axis2_array)[0] * 2
}, {
'NAXIS4': ''
}, {
'CUNIT1': 'foo'
}, {
'CUNIT2': 'foo'
}]
for i, hdr_dict in enumerate(header_vals_to_change):
beam_in.write_beamfits(write_file, clobber=True)
keyword = list(hdr_dict.keys())[0]
new_val = hdr_dict[keyword]
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
hdunames = uvutils._fits_indexhdus(F)
basisvec_hdu = F[hdunames['BASISVEC']]
basisvec_hdr = basisvec_hdu.header
basisvec_data = basisvec_hdu.data
bandpass_hdu = F[hdunames['BANDPARM']]
if 'NAXIS' in keyword:
ax_num = keyword.split('NAXIS')[1]
if ax_num != '':
ax_num = int(ax_num)
ax_use = len(basisvec_data.shape) - ax_num
new_arrays = np.split(basisvec_data,
basisvec_hdr[keyword],
axis=ax_use)
basisvec_data = new_arrays[0]
else:
basisvec_data = np.split(basisvec_data,
basisvec_hdr['NAXIS1'],
axis=len(basisvec_data.shape) - 1)[0]
else:
basisvec_hdr[keyword] = new_val
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
basisvec_hdu = fits.ImageHDU(data=basisvec_data, header=basisvec_hdr)
hdulist = fits.HDUList([prihdu, basisvec_hdu, bandpass_hdu])
if float(astropy.__version__[0:3]) < 1.3:
hdulist.writeto(write_file, clobber=True)
else:
hdulist.writeto(write_file, overwrite=True)
nt.assert_raises(ValueError, beam_out.read_beamfits, write_file)
def test_select_read(tmp_path):
uvfits_uv = UVData()
uvfits_uv2 = UVData()
uvfits_file = os.path.join(DATA_PATH,
"day2_TDEM0003_10s_norx_1src_1spw.uvfits")
# select on antennas
ants_to_keep = np.array([0, 19, 11, 24, 3, 23, 1, 20, 21])
uvfits_uv.read(uvfits_file, antenna_nums=ants_to_keep)
uvfits_uv2.read(uvfits_file)
uvfits_uv2.select(antenna_nums=ants_to_keep)
assert uvfits_uv == uvfits_uv2
# select on frequency channels
chans_to_keep = np.arange(12, 22)
uvfits_uv.read(uvfits_file, freq_chans=chans_to_keep)
uvfits_uv2.read(uvfits_file)
uvfits_uv2.select(freq_chans=chans_to_keep)
assert uvfits_uv == uvfits_uv2
# check writing & reading single frequency files
uvfits_uv.select(freq_chans=[0])
testfile = str(tmp_path / "outtest_casa.uvfits")
uvfits_uv.write_uvfits(testfile)
uvfits_uv2.read(testfile)
assert uvfits_uv == uvfits_uv2
# select on pols
pols_to_keep = [-1, -2]
uvfits_uv.read(uvfits_file, polarizations=pols_to_keep)
uvfits_uv2.read(uvfits_file)
uvfits_uv2.select(polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
# select on read using time_range
unique_times = np.unique(uvfits_uv.time_array)
uvfits_uv.read(uvfits_file, time_range=[unique_times[0], unique_times[1]])
uvfits_uv2.read(uvfits_file)
uvfits_uv2.select(times=unique_times[0:2])
assert uvfits_uv == uvfits_uv2
# now test selecting on multiple axes
# frequencies first
uvfits_uv.read(
uvfits_file,
antenna_nums=ants_to_keep,
freq_chans=chans_to_keep,
polarizations=pols_to_keep,
)
uvfits_uv2.read(uvfits_file)
uvfits_uv2.select(antenna_nums=ants_to_keep,
freq_chans=chans_to_keep,
polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
# baselines first
ants_to_keep = np.array([0, 1])
uvfits_uv.read(
uvfits_file,
antenna_nums=ants_to_keep,
freq_chans=chans_to_keep,
polarizations=pols_to_keep,
)
uvfits_uv2.read(uvfits_file)
uvfits_uv2.select(antenna_nums=ants_to_keep,
freq_chans=chans_to_keep,
polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
# polarizations first
ants_to_keep = np.array([0, 1, 2, 3, 6, 7, 8, 11, 14, 18, 19, 20, 21, 22])
chans_to_keep = np.arange(12, 64)
uvfits_uv.read(
uvfits_file,
antenna_nums=ants_to_keep,
freq_chans=chans_to_keep,
polarizations=pols_to_keep,
)
uvfits_uv2.read(uvfits_file)
uvfits_uv2.select(antenna_nums=ants_to_keep,
freq_chans=chans_to_keep,
polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
# repeat with no spw file
uvfitsfile_no_spw = os.path.join(DATA_PATH,
"zen.2456865.60537.xy.uvcRREAAM.uvfits")
# select on antennas
ants_to_keep = np.array([2, 4, 5])
uvfits_uv.read(uvfitsfile_no_spw, antenna_nums=ants_to_keep)
uvfits_uv2.read(uvfitsfile_no_spw)
uvfits_uv2.select(antenna_nums=ants_to_keep)
assert uvfits_uv == uvfits_uv2
# select on frequency channels
chans_to_keep = np.arange(4, 8)
uvfits_uv.read(uvfitsfile_no_spw, freq_chans=chans_to_keep)
uvfits_uv2.read(uvfitsfile_no_spw)
uvfits_uv2.select(freq_chans=chans_to_keep)
assert uvfits_uv == uvfits_uv2
# select on pols
# this requires writing a new file because the no spw file we have has only 1 pol
with fits.open(uvfits_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
raw_data_array = raw_data_array[:, :, :, 0, :, :, :]
vis_hdr["NAXIS"] = 6
vis_hdr["NAXIS5"] = vis_hdr["NAXIS6"]
vis_hdr["CTYPE5"] = vis_hdr["CTYPE6"]
vis_hdr["CRVAL5"] = vis_hdr["CRVAL6"]
vis_hdr["CDELT5"] = vis_hdr["CDELT6"]
vis_hdr["CRPIX5"] = vis_hdr["CRPIX6"]
vis_hdr["CROTA5"] = vis_hdr["CROTA6"]
vis_hdr["NAXIS6"] = vis_hdr["NAXIS7"]
vis_hdr["CTYPE6"] = vis_hdr["CTYPE7"]
vis_hdr["CRVAL6"] = vis_hdr["CRVAL7"]
vis_hdr["CDELT6"] = vis_hdr["CDELT7"]
vis_hdr["CRPIX6"] = vis_hdr["CRPIX7"]
vis_hdr["CROTA6"] = vis_hdr["CROTA7"]
vis_hdr.pop("NAXIS7")
vis_hdr.pop("CTYPE7")
vis_hdr.pop("CRVAL7")
vis_hdr.pop("CDELT7")
vis_hdr.pop("CRPIX7")
vis_hdr.pop("CROTA7")
par_names = vis_hdu.data.parnames
group_parameter_list = [
vis_hdu.data.par(ind) for ind in range(len(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"]]
write_file = str(tmp_path / "outtest_casa.uvfits")
hdulist = fits.HDUList(hdus=[vis_hdu, ant_hdu])
hdulist.writeto(write_file, overwrite=True)
pols_to_keep = [-1, -2]
uvfits_uv.read(write_file, polarizations=pols_to_keep)
uvfits_uv2.read(uvfits_file)
uvfits_uv2.select(polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
def test_read_oldcalfits():
"""
Test for proper behavior with old calfits files.
"""
# start with gain type files
cal_in = UVCal()
cal_out = UVCal()
testfile = os.path.join(DATA_PATH, 'zen.2457698.40355.xx.fitsA')
write_file = os.path.join(DATA_PATH, 'test/outtest_omnical.fits')
message = testfile + ' appears to be an old calfits format which'
uvtest.checkWarnings(cal_in.read_calfits, [testfile], message=message)
# add total_quality_array so that can be tested as well
cal_in.total_quality_array = np.zeros(cal_in._total_quality_array.expected_shape(cal_in))
# now read in the file and remove various CRPIX and CRVAL keywords to
# emulate old calfits files
header_vals_to_remove = [{'primary': 'CRVAL5'}, {'primary': 'CRPIX4'},
{'totqual': 'CRVAL4'}]
messages = [write_file, 'This file', write_file]
messages = [m + ' appears to be an old calfits format' for m in messages]
for i, hdr_dict in enumerate(header_vals_to_remove):
cal_in.write_calfits(write_file, clobber=True)
unit = list(hdr_dict.keys())[0]
keyword = hdr_dict[unit]
F = fits.open(write_file)
data = F[0].data
primary_hdr = F[0].header
hdunames = uvutils._fits_indexhdus(F)
ant_hdu = F[hdunames['ANTENNAS']]
totqualhdu = F[hdunames['TOTQLTY']]
totqualhdr = totqualhdu.header
if unit == 'primary':
primary_hdr.pop(keyword)
elif unit == 'totqual':
totqualhdr.pop(keyword)
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, ant_hdu])
totqualhdu = fits.ImageHDU(data=totqualhdu.data, header=totqualhdr)
hdulist.append(totqualhdu)
if float(astropy.__version__[0:3]) < 1.3:
hdulist.writeto(write_file, clobber=True)
else:
hdulist.writeto(write_file, overwrite=True)
uvtest.checkWarnings(cal_out.read_calfits, [write_file], message=messages[i])
nt.assert_equal(cal_in, cal_out)
nt.assert_raises(KeyError, cal_out.read_calfits, write_file, strict_fits=True)
# now with delay type files
cal_in = UVCal()
cal_out = UVCal()
testfile = os.path.join(DATA_PATH, 'zen.2457698.40355.xx.HH.uvc.fits')
write_file = os.path.join(DATA_PATH, 'test/outtest_firstcal.fits')
message = [testfile + ' appears to be an old calfits format which',
testfile + ' appears to be an old calfits format for delay files']
uvtest.checkWarnings(cal_in.read_calfits, [testfile], message=message,
nwarnings=2)
# add total_quality_array so that can be tested as well
cal_in.total_quality_array = np.zeros(cal_in._total_quality_array.expected_shape(cal_in))
# now read in the file and remove various CRPIX and CRVAL keywords to
# emulate old calfits files
header_vals_to_remove = [{'primary': 'CRVAL5'}, {'flag': 'CRVAL5'},
{'flag': 'CRPIX4'}, {'totqual': 'CRVAL4'}]
messages = [write_file, 'This file', 'This file', write_file]
messages = [m + ' appears to be an old calfits format' for m in messages]
for i, hdr_dict in enumerate(header_vals_to_remove):
cal_in.write_calfits(write_file, clobber=True)
unit = list(hdr_dict.keys())[0]
keyword = hdr_dict[unit]
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
totqualhdu = F[hdunames['TOTQLTY']]
totqualhdr = totqualhdu.header
if unit == 'primary':
primary_hdr.pop(keyword)
elif unit == 'flag':
flag_hdr.pop(keyword)
elif unit == 'totqual':
totqualhdr.pop(keyword)
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)
totqualhdu = fits.ImageHDU(data=totqualhdu.data, header=totqualhdr)
hdulist.append(totqualhdu)
if float(astropy.__version__[0:3]) < 1.3:
hdulist.writeto(write_file, clobber=True)
else:
hdulist.writeto(write_file, overwrite=True)
uvtest.checkWarnings(cal_out.read_calfits, [write_file], message=messages[i])
nt.assert_equal(cal_in, cal_out)
nt.assert_raises(KeyError, cal_out.read_calfits, write_file, strict_fits=True)
def test_read_cst_write_read_fits(cst_efield_1freq, tmp_path):
beam_in = cst_efield_1freq.copy()
beam_out = UVBeam()
# add optional parameters for testing purposes
beam_in.extra_keywords = {"KEY1": "test_keyword"}
beam_in.x_orientation = "east"
beam_in.reference_impedance = 340.0
beam_in.receiver_temperature_array = np.random.normal(
50.0, 5, size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.loss_array = np.random.normal(50.0,
5,
size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.mismatch_array = np.random.normal(0.0,
1.0,
size=(beam_in.Nspws,
beam_in.Nfreqs))
beam_in.s_parameters = np.random.normal(0.0,
0.3,
size=(4, beam_in.Nspws,
beam_in.Nfreqs))
beam_in.interpolation_function = "az_za_simple"
beam_in.freq_interp_kind = "linear"
write_file = str(tmp_path / "outtest_beam.fits")
beam_in.write_beamfits(write_file, clobber=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# redo for power beam
del beam_in
beam_in = cst_efield_1freq
# read in efield and convert to power to test cross-pols
beam_in.efield_to_power()
# add optional parameters for testing purposes
beam_in.extra_keywords = {"KEY1": "test_keyword"}
beam_in.x_orientation = "east"
beam_in.reference_impedance = 340.0
beam_in.receiver_temperature_array = np.random.normal(
50.0, 5, size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.loss_array = np.random.normal(50.0,
5,
size=(beam_in.Nspws, beam_in.Nfreqs))
beam_in.mismatch_array = np.random.normal(0.0,
1.0,
size=(beam_in.Nspws,
beam_in.Nfreqs))
beam_in.s_parameters = np.random.normal(0.0,
0.3,
size=(4, beam_in.Nspws,
beam_in.Nfreqs))
beam_in.write_beamfits(write_file, clobber=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# now replace 'power' with 'intensity' for btype
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
primary_hdr["BTYPE"] = "Intensity"
hdunames = uvutils._fits_indexhdus(fname)
bandpass_hdu = fname[hdunames["BANDPARM"]]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# now remove coordsys but leave ctypes 1 & 2
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
primary_hdr.pop("COORDSYS")
hdunames = uvutils._fits_indexhdus(fname)
bandpass_hdu = fname[hdunames["BANDPARM"]]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
# now change frequency units
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
primary_hdr["CUNIT3"] = "MHz"
primary_hdr["CRVAL3"] = primary_hdr["CRVAL3"] / 1e6
primary_hdr["CDELT3"] = primary_hdr["CRVAL3"] / 1e6
hdunames = uvutils._fits_indexhdus(fname)
bandpass_hdu = fname[hdunames["BANDPARM"]]
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
beam_out.read_beamfits(write_file)
assert beam_in == beam_out
def test_readwriteread(tmp_path):
"""
CASA tutorial uvfits loopback test.
Read in uvfits file, write out new uvfits file, read back in and check for
object equality.
"""
uv_in = UVData()
uv_out = UVData()
testfile = os.path.join(DATA_PATH,
"day2_TDEM0003_10s_norx_1src_1spw.uvfits")
write_file = str(tmp_path / "outtest_casa.uvfits")
uv_in.read(testfile)
uv_in.write_uvfits(write_file)
uv_out.read(write_file)
assert uv_in == uv_out
# test that it works with write_lst = False
uv_in.write_uvfits(write_file, write_lst=False)
uv_out.read(write_file)
assert uv_in == uv_out
# check that if x_orientation is set, it's read back out properly
uv_in.x_orientation = "east"
uv_in.write_uvfits(write_file)
uv_out.read(write_file)
assert uv_in == uv_out
# check that if antenna_diameters is set, it's read back out properly
uv_in.read(testfile)
uv_in.antenna_diameters = np.zeros(
(uv_in.Nants_telescope, ), dtype=np.float) + 14.0
uv_in.write_uvfits(write_file)
uv_out.read(write_file)
assert uv_in == uv_out
# check that if antenna_numbers are > 256 everything works
uv_in.read(testfile)
uv_in.antenna_numbers = uv_in.antenna_numbers + 256
uv_in.ant_1_array = uv_in.ant_1_array + 256
uv_in.ant_2_array = uv_in.ant_2_array + 256
uv_in.baseline_array = uv_in.antnums_to_baseline(uv_in.ant_1_array,
uv_in.ant_2_array)
uvtest.checkWarnings(
uv_in.write_uvfits,
[write_file],
message=
"antnums_to_baseline: found > 256 antennas, using 2048 baseline",
)
uv_out.read(write_file)
assert uv_in == uv_out
# check missing telescope_name, timesys vs timsys spelling, xyz_telescope_frame=????
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()
vis_hdr.pop("TELESCOP")
vis_hdu.header = vis_hdr
ant_hdu = hdu_list[hdunames["AIPS AN"]]
ant_hdr = ant_hdu.header.copy()
time_sys = ant_hdr.pop("TIMSYS")
ant_hdr["TIMESYS"] = time_sys
ant_hdr["FRAME"] = "????"
ant_hdu.header = ant_hdr
hdulist = fits.HDUList(hdus=[vis_hdu, ant_hdu])
hdulist.writeto(write_file, overwrite=True)
uv_out.read(write_file)
assert uv_out.telescope_name == "EVLA"
assert uv_out.timesys == time_sys
# check error if timesys is 'IAT'
uv_in.read(testfile)
uv_in.timesys = "IAT"
with pytest.raises(ValueError) as cm:
uv_in.write_uvfits(write_file)
assert str(cm.value).startswith(
"This file has a time system IAT. "
'Only "UTC" time system files are supported')
uv_in.timesys = "UTC"
# 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_file, overwrite=True)
with pytest.raises(ValueError) as cm:
uvtest.checkWarnings(
uv_out.read,
func_args=[write_file],
message=[
"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",
],
nwarnings=4,
category=[
UserWarning,
astropy._erfa.core.ErfaWarning,
astropy._erfa.core.ErfaWarning,
UserWarning,
],
)
assert str(cm.value).startswith(
"integration time not specified and only one time present")
# 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
uvtest.checkWarnings(uv_in.write_uvfits, [write_file],
message="Some unflagged data has nsample = 0")
def test_healpix_errors(cst_efield_1freq_cut_healpix, tmp_path):
beam_in = cst_efield_1freq_cut_healpix.copy()
beam_out = UVBeam()
write_file = str(tmp_path / "outtest_beam_hpx.fits")
# now change values for various items in primary hdu to test errors
header_vals_to_change = [{"CTYPE1": "foo"}, {"NAXIS1": ""}]
for i, hdr_dict in enumerate(header_vals_to_change):
beam_in.write_beamfits(write_file, clobber=True)
keyword = list(hdr_dict.keys())[0]
new_val = hdr_dict[keyword]
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
hdunames = uvutils._fits_indexhdus(fname)
basisvec_hdu = fname[hdunames["BASISVEC"]]
hpx_hdu = fname[hdunames["HPX_INDS"]]
bandpass_hdu = fname[hdunames["BANDPARM"]]
if "NAXIS" in keyword:
ax_num = keyword.split("NAXIS")[1]
if ax_num != "":
ax_num = int(ax_num)
ax_use = len(data.shape) - ax_num
new_arrays = np.split(data, primary_hdr[keyword], axis=ax_use)
data = new_arrays[0]
else:
data = np.squeeze(
np.split(data,
primary_hdr["NAXIS1"],
axis=len(data.shape) - 1)[0])
else:
primary_hdr[keyword] = new_val
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
hdulist = fits.HDUList([prihdu, basisvec_hdu, hpx_hdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
pytest.raises(ValueError, beam_out.read_beamfits, write_file)
# now change values for various items in basisvec hdu to not match primary hdu
beam_in = cst_efield_1freq_cut_healpix
header_vals_to_change = [{"CTYPE1": "foo"}, {"NAXIS1": ""}]
for i, hdr_dict in enumerate(header_vals_to_change):
beam_in.write_beamfits(write_file, clobber=True)
keyword = list(hdr_dict.keys())[0]
new_val = hdr_dict[keyword]
fname = fits.open(write_file)
data = fname[0].data
primary_hdr = fname[0].header
hdunames = uvutils._fits_indexhdus(fname)
basisvec_hdu = fname[hdunames["BASISVEC"]]
basisvec_hdr = basisvec_hdu.header
basisvec_data = basisvec_hdu.data
hpx_hdu = fname[hdunames["HPX_INDS"]]
bandpass_hdu = fname[hdunames["BANDPARM"]]
if "NAXIS" in keyword:
ax_num = keyword.split("NAXIS")[1]
if ax_num != "":
ax_num = int(ax_num)
ax_use = len(basisvec_data.shape) - ax_num
new_arrays = np.split(basisvec_data,
basisvec_hdr[keyword],
axis=ax_use)
basisvec_data = new_arrays[0]
else:
basisvec_data = np.split(
basisvec_data,
basisvec_hdr["NAXIS1"],
axis=len(basisvec_data.shape) - 1,
)[0]
else:
basisvec_hdr[keyword] = new_val
prihdu = fits.PrimaryHDU(data=data, header=primary_hdr)
basisvec_hdu = fits.ImageHDU(data=basisvec_data, header=basisvec_hdr)
hdulist = fits.HDUList([prihdu, basisvec_hdu, hpx_hdu, bandpass_hdu])
hdulist.writeto(write_file, overwrite=True)
pytest.raises(ValueError, beam_out.read_beamfits, write_file)
def test_select_read():
uvfits_uv = UVData()
uvfits_uv2 = UVData()
uvfits_file = os.path.join(DATA_PATH,
'day2_TDEM0003_10s_norx_1src_1spw.uvfits')
# select on antennas
ants_to_keep = np.array([0, 19, 11, 24, 3, 23, 1, 20, 21])
uvtest.checkWarnings(uvfits_uv.read, [uvfits_file],
{'antenna_nums': ants_to_keep},
message='Telescope EVLA is not')
uvtest.checkWarnings(uvfits_uv2.read, [uvfits_file],
message='Telescope EVLA is not')
uvfits_uv2.select(antenna_nums=ants_to_keep)
assert uvfits_uv == uvfits_uv2
# select on frequency channels
chans_to_keep = np.arange(12, 22)
uvtest.checkWarnings(uvfits_uv.read, [uvfits_file],
{'freq_chans': chans_to_keep},
message='Telescope EVLA is not')
uvtest.checkWarnings(uvfits_uv2.read, [uvfits_file],
message='Telescope EVLA is not')
uvfits_uv2.select(freq_chans=chans_to_keep)
assert uvfits_uv == uvfits_uv2
# check writing & reading single frequency files
uvfits_uv.select(freq_chans=[0])
testfile = os.path.join(DATA_PATH, 'test/outtest_casa.uvfits')
uvfits_uv.write_uvfits(testfile)
uvtest.checkWarnings(uvfits_uv2.read, [testfile],
message='Telescope EVLA is not')
assert uvfits_uv == uvfits_uv2
# select on pols
pols_to_keep = [-1, -2]
uvtest.checkWarnings(uvfits_uv.read, [uvfits_file],
{'polarizations': pols_to_keep},
message='Telescope EVLA is not')
uvtest.checkWarnings(uvfits_uv2.read, [uvfits_file],
message='Telescope EVLA is not')
uvfits_uv2.select(polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
# select on read using time_range
unique_times = np.unique(uvfits_uv.time_array)
uvtest.checkWarnings(uvfits_uv.read, [uvfits_file],
{'time_range': [unique_times[0], unique_times[1]]},
nwarnings=2,
message=[
'Warning: "time_range" keyword is set',
'Telescope EVLA is not'
])
uvtest.checkWarnings(uvfits_uv2.read, [uvfits_file],
message='Telescope EVLA is not')
uvfits_uv2.select(times=unique_times[0:2])
assert uvfits_uv == uvfits_uv2
# now test selecting on multiple axes
# frequencies first
uvtest.checkWarnings(uvfits_uv.read, [uvfits_file], {
'antenna_nums': ants_to_keep,
'freq_chans': chans_to_keep,
'polarizations': pols_to_keep
},
message='Telescope EVLA is not')
uvtest.checkWarnings(uvfits_uv2.read, [uvfits_file],
message='Telescope EVLA is not')
uvfits_uv2.select(antenna_nums=ants_to_keep,
freq_chans=chans_to_keep,
polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
# baselines first
ants_to_keep = np.array([0, 1])
uvtest.checkWarnings(uvfits_uv.read, [uvfits_file], {
'antenna_nums': ants_to_keep,
'freq_chans': chans_to_keep,
'polarizations': pols_to_keep
},
message='Telescope EVLA is not')
uvtest.checkWarnings(uvfits_uv2.read, [uvfits_file],
message='Telescope EVLA is not')
uvfits_uv2.select(antenna_nums=ants_to_keep,
freq_chans=chans_to_keep,
polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
# polarizations first
ants_to_keep = np.array([0, 1, 2, 3, 6, 7, 8, 11, 14, 18, 19, 20, 21, 22])
chans_to_keep = np.arange(12, 64)
uvtest.checkWarnings(uvfits_uv.read, [uvfits_file], {
'antenna_nums': ants_to_keep,
'freq_chans': chans_to_keep,
'polarizations': pols_to_keep
},
message='Telescope EVLA is not')
uvtest.checkWarnings(uvfits_uv2.read, [uvfits_file],
message='Telescope EVLA is not')
uvfits_uv2.select(antenna_nums=ants_to_keep,
freq_chans=chans_to_keep,
polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
# repeat with no spw file
uvfitsfile_no_spw = os.path.join(DATA_PATH,
'zen.2456865.60537.xy.uvcRREAAM.uvfits')
# select on antennas
ants_to_keep = np.array([2, 4, 5])
uvtest.checkWarnings(uvfits_uv.read, [uvfitsfile_no_spw],
{'antenna_nums': ants_to_keep},
known_warning='paper_uvfits')
uvtest.checkWarnings(uvfits_uv2.read, [uvfitsfile_no_spw],
known_warning='paper_uvfits')
uvfits_uv2.select(antenna_nums=ants_to_keep)
assert uvfits_uv == uvfits_uv2
# select on frequency channels
chans_to_keep = np.arange(4, 8)
uvtest.checkWarnings(uvfits_uv.read, [uvfitsfile_no_spw],
{'freq_chans': chans_to_keep},
known_warning='paper_uvfits')
uvtest.checkWarnings(uvfits_uv2.read, [uvfitsfile_no_spw],
known_warning='paper_uvfits')
uvfits_uv2.select(freq_chans=chans_to_keep)
assert uvfits_uv == uvfits_uv2
# select on pols
# this requires writing a new file because the no spw file we have has only 1 pol
with fits.open(uvfits_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
raw_data_array = raw_data_array[:, :, :, 0, :, :, :]
vis_hdr['NAXIS'] = 6
vis_hdr['NAXIS5'] = vis_hdr['NAXIS6']
vis_hdr['CTYPE5'] = vis_hdr['CTYPE6']
vis_hdr['CRVAL5'] = vis_hdr['CRVAL6']
vis_hdr['CDELT5'] = vis_hdr['CDELT6']
vis_hdr['CRPIX5'] = vis_hdr['CRPIX6']
vis_hdr['CROTA5'] = vis_hdr['CROTA6']
vis_hdr['NAXIS6'] = vis_hdr['NAXIS7']
vis_hdr['CTYPE6'] = vis_hdr['CTYPE7']
vis_hdr['CRVAL6'] = vis_hdr['CRVAL7']
vis_hdr['CDELT6'] = vis_hdr['CDELT7']
vis_hdr['CRPIX6'] = vis_hdr['CRPIX7']
vis_hdr['CROTA6'] = vis_hdr['CROTA7']
vis_hdr.pop('NAXIS7')
vis_hdr.pop('CTYPE7')
vis_hdr.pop('CRVAL7')
vis_hdr.pop('CDELT7')
vis_hdr.pop('CRPIX7')
vis_hdr.pop('CROTA7')
par_names = vis_hdu.data.parnames
group_parameter_list = [
vis_hdu.data.par(ind) for ind in range(len(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']]
write_file = os.path.join(DATA_PATH, 'test/outtest_casa.uvfits')
hdulist = fits.HDUList(hdus=[vis_hdu, ant_hdu])
hdulist.writeto(write_file, overwrite=True)
pols_to_keep = [-1, -2]
uvtest.checkWarnings(uvfits_uv.read, [write_file],
{'polarizations': pols_to_keep},
message='Telescope EVLA is not')
uvtest.checkWarnings(uvfits_uv2.read, [write_file],
message='Telescope EVLA is not')
uvfits_uv2.select(polarizations=pols_to_keep)
assert uvfits_uv == uvfits_uv2
