def find_gains_for_baseline(self, bl, t):
ant1, ant2 = baselines_2_ants([bl])
# (N, #if, #pol)
gains1 = self.find_gains_for_antenna(ant1, t)
gains2 = self.find_gains_for_antenna(ant2, t)
gains12 = np.asarray([
gains1[..., 0] * np.conjugate(gains2[..., 0]),
gains1[..., 1] * np.conjugate(gains2[..., 1]),
gains1[..., 0] * np.conjugate(gains2[..., 1]),
gains1[..., 1] * np.conjugate(gains2[..., 0])
])
return gains12
def find_gains_for_baseline(self, t, bl):
"""
Method that find complex antenna gains for given time and baseline.
Given time ``t`` and baseline ``bl`` this method finds indxs of
``gains`` array of ``_data`` structured array of ``self``for ``ant1``,
containing ``t`` and ``ant2``, containing ``t`` and returns array of
gains (gain1 * gain2^*) for baseline ``bl`` for time moment ``t`` with
shape (#stokes, #if), where ant1 < ant2.
:param t:
Time for which fetch gains.
:param bl:
Baseline for which fetch gains.
:return:
Numpy.ndarray.
"""
ant1, ant2 = baselines_2_ants([bl])
# Find indx of gains entries containing ``t`` with ant1 & ant2
indx1 = np.where((t <= self._data['stop']) & (t >= self._data['start'])
& (self._data['antenna'] == ant1))[0]
indx2 = np.where((t <= self._data['stop']) & (t >= self._data['start'])
& (self._data['antenna'] == ant2))[0]
# Now each gains# has shape (#if, #pol)
gains1 = np.squeeze(self._data[indx1]['gains'])
gains2 = np.squeeze(self._data[indx2]['gains'])
# ``gains12`` has shape (#stokes, #nif)
gains12 = np.asarray([
gains1[:, 0] * np.conjugate(gains2[:, 0]),
gains1[:, 1] * np.conjugate(gains2[:, 1]),
gains1[:, 0] * np.conjugate(gains2[:, 1]),
gains1[:, 1] * np.conjugate(gains2[:, 0])
])
return gains12
# Then second row, etc...
i += 1
j = 0
except IndexError:
break
fig.show()
fig.savefig("{}.{}".format(os.path.join(base_path, 'res_cc'), 'png'),
bbox_inches='tight', dpi=400)
matplotlib.pyplot.close()
# Plot uv-coverage
label_size = 12
matplotlib.rcParams['xtick.labelsize'] = label_size
matplotlib.rcParams['ytick.labelsize'] = label_size
for i, color in enumerate(colors):
uvdata_r.uv_coverage(baselines=baselines_2_ants(uvdata_r.baselines)[i],
sym='.{}'.format(color))
matplotlib.pyplot.show()
matplotlib.pyplot.savefig('/home/ilya/sandbox/heteroboot/uv.png',
bbox_inches='tight', dpi=400)
matplotlib.pyplot.close()
# Plot several histograms
label_size = 12
matplotlib.rcParams['xtick.labelsize'] = label_size
matplotlib.rcParams['ytick.labelsize'] = label_size
for i, color in enumerate(colors):
baseline = uvdata_r.baselines[i]
res = uvdata_r._choose_uvdata(baselines=[baseline], freq_average=True,
stokes='I')[0]
matplotlib.pyplot.hist(res.real, color="#4682b4", range=[-0.16, 0.16],
def __iter__(self):
# def create_train_test_uvfits(self):
all_baselines = self.uvdata.baselines
for bl, scans_times in self.uvdata.baselines_scans_times.items():
print("BASELINE = ", bl)
self.cur_bl = bl
ta, tb = baselines_2_ants([bl])
ta = self.uvdata.antenna_mapping[ta]
tb = self.uvdata.antenna_mapping[tb]
n_scans = len(scans_times)
# rnd_scan_number = np.random.randint(n_scans)
half_scan_number = int(n_scans / 2)
# if half_scan_number == 0:
# half_scan_number = 1
for scan_num, scan_times in enumerate(scans_times):
self.cur_scan = scan_num
if scan_num != half_scan_number:
continue
print("SCAN # ", scan_num)
start_time = Time(scan_times[0], format="jd")
stop_time = Time(scan_times[-1], format="jd")
# Train data
# flag_baseline_scan(self.original_uvfits, os.path.join(self.outdir, "cv_bl_{}_scan_{}_train.uvf".format(int(bl), scan_num)), ta, tb,
# start_time=start_time, stop_time=stop_time, except_time_range=False)
flag_baseline_scan(self.original_uvfits,
os.path.join(self.outdir,
self.train_uvfits),
ta,
tb,
start_time=start_time,
stop_time=stop_time,
except_time_range=False)
# Test data
# Manage target baseline
# flag_baseline_scan(self.original_uvfits, os.path.join(self.outdir, "cv_bl_{}_scan_{}_test.uvf".format(int(bl), scan_num)), ta, tb,
# start_time=start_time, stop_time=stop_time, except_time_range=True)
flag_baseline_scan(self.original_uvfits,
os.path.join(self.outdir, self.test_uvfits),
ta,
tb,
start_time=start_time,
stop_time=stop_time,
except_time_range=True)
# Manage all others baselines
for other_bl in all_baselines:
ta_other, tb_other = baselines_2_ants([other_bl])
ta_other = self.uvdata.antenna_mapping[ta_other]
tb_other = self.uvdata.antenna_mapping[tb_other]
if ta in (ta_other, tb_other) and tb in (ta_other,
tb_other):
continue
else:
# flag_baseline(os.path.join(self.outdir, "cv_bl_{}_scan_{}_test.uvf".format(int(bl), scan_num)),
# os.path.join(self.outdir, "cv_bl_{}_scan_{}_test.uvf".format(int(bl), scan_num)),
# ta_other, tb_other)
flag_baseline(
os.path.join(self.outdir, self.test_uvfits),
os.path.join(self.outdir, self.test_uvfits),
ta_other, tb_other)
yield self.train_uvfits, self.test_uvfits
uvdata_m.substitute([ccmodel])
uvdata_r = uvdata - uvdata_m
baseline = uvdata.baselines[0]
print "baseline {}".format(baseline)
i, indxs_i = uvdata._choose_uvdata(baselines=[baseline], IF=1, stokes='I')
rl, indxs_rl = uvdata._choose_uvdata(baselines=[baseline], IF=1, stokes='RL')
lr, indxs_lr = uvdata._choose_uvdata(baselines=[baseline], IF=1, stokes='LR')
i = i[:, 0, 0]
rl = rl[:, 0, 0]
lr = lr[:, 0, 0]
import astropy.io.fits as pf
hdus = pf.open(os.path.join(uv_data_dir, uv_fname))
hdu = hdus[3]
ant1, ant2 = baselines_2_ants([baseline])
ant1_name = hdu.data['ANNAME'][ant1 - 1]
ant2_name = hdu.data['ANNAME'][ant2 - 1]
ra = float(hdus[0].header['OBSRA'])
dec = float(hdus[0].header['OBSDEC'])
tzero = hdu.header['PZERO{}'.format(
find_card_from_header(hdu.header, value='DATE')[0][0][-1])]
times = uvdata.data['time'][indxs_i] + tzero
pa_br = np.array(PA(times, ra, dec, br_lat, br_long))
pa_fd = np.array(PA(times, ra, dec, fd_lat, fd_long))
delta_d = 0.05
d_br = np.random.normal(0, delta_d) + 1j * np.random.normal(0, delta_d)
d_fd = np.random.normal(0, delta_d) + 1j * np.random.normal(0, delta_d)