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