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