def test_azel_to_enu(self):
"""Closure tests for (az, el) to ENU conversion and vice versa."""
e, n, u = katpoint.azel_to_enu(self.az, self.el)
new_az, new_el = katpoint.enu_to_azel(e, n, u)
assert_angles_almost_equal(new_az, self.az, decimal=15)
assert_angles_almost_equal(new_el, self.el, decimal=15)
# How about an all-sky fringe pattern for the first baseline?
#############################################################
baseline_m = ant_a.baseline_toward(ant_b)
lat = ant_a.observer.lat
rf_freq = 1.8e9
# In terms of (az, el)
x_range, y_range = np.linspace(-1., 1., 201), np.linspace(-1., 1., 201)
x_grid, y_grid = np.meshgrid(x_range, y_range)
xx, yy = x_grid.flatten(), y_grid.flatten()
outside_circle = xx * xx + yy * yy > 1.0
xx[outside_circle] = yy[outside_circle] = np.nan
az, el = katpoint.plane_to_sphere['SIN'](0.0, np.pi / 2.0, xx, yy)
source_vec = katpoint.azel_to_enu(az, el)
geom_delay = -np.dot(baseline_m, source_vec) / katpoint.lightspeed
turns = geom_delay * rf_freq
phase = turns - np.floor(turns)
plt.figure(1)
plt.clf()
plt.imshow(phase.reshape(x_grid.shape),
origin='lower',
extent=[x_range[0], x_range[-1], y_range[0], y_range[-1]])
# In terms of (ha, dec)
# One second resolution on hour angle - picks up fast fringes that way
ha_range = np.linspace(-12., 12., 86401.)
dec_range = np.linspace(-90., katpoint.rad2deg(lat) + 90., 101)
ha_grid, dec_grid = np.meshgrid(ha_range, dec_range)
num_ts = data.shape[0]
if state != 'track':
print "scan %3d (%4d samples) skipped '%s'" % (scan_ind, num_ts, state)
continue
if num_ts < 2:
print "scan %3d (%4d samples) skipped - too short" % (scan_ind, num_ts)
continue
if target.name in excluded_targets:
print "scan %3d (%4d samples) skipped - excluded '%s'" % (scan_ind, num_ts, target.name)
continue
# Extract visibilities for scan as an array of shape (T, F, B)
vis = data.vis[:]
ts = data.timestamps[:]
# Obtain unit vectors pointing from array antenna to target for each timestamp in scan
az, el = target.azel(ts, array_ant)
targetdir = np.array(katpoint.azel_to_enu(az, el))
# Invert sign of target vector, as positive dot product with baseline implies negative delay / advance
# Augment target vector with a 1 to be 4-dimensional, as this allows fitting of constant (receiver) delay
# This array has shape (4, T), with the augmented target vectors as columns
scan_augmented_targetdir = np.vstack((-targetdir, np.ones(len(el))))
# Create section of design matrix with shape (B P, T), by inserting target dir vectors in right places
augm_block = np.dot(bl_parameter_map, scan_augmented_targetdir)
# Rearrange shape to (P, B T) to be compatible with ravelled delay data, which has shape (B T,)
augm_block = augm_block.reshape(num_bls, num_params, num_ts).swapaxes(0, 1).reshape(num_params, -1)
augmented_targetdir.append(augm_block)
# Group delay is proportional to phase slope across the band - estimate this as the phase difference between
# consecutive frequency channels calculated via np.diff. Pick antenna 1 as reference antenna -> correlation
# product XY* means we actually measure phase(antenna1) - phase(antenna2), therefore flip the sign.
# Also divide by channel frequency difference, which correctly handles gaps in frequency coverage.
phase_diff_per_Hz = np.diff(-np.angle(vis), axis=1) / freq_diff[:, np.newaxis]
# Convert to a delay in seconds
num_ts = data.shape[0]
if state != 'track':
print "scan %3d (%4d samples) skipped '%s'" % (scan_ind, num_ts, state)
continue
if num_ts < 2:
print "scan %3d (%4d samples) skipped - too short" % (scan_ind, num_ts)
continue
if target.name in excluded_targets:
print "scan %3d (%4d samples) skipped - excluded '%s'" % (scan_ind, num_ts, target.name)
continue
# Extract visibilities for scan as an array of shape (T, F, B)
vis = data.vis[:]
ts = data.timestamps[:]
# Obtain unit vectors pointing from array antenna to target for each timestamp in scan
az, el = target.azel(ts, array_ant)
targetdir = np.array(katpoint.azel_to_enu(az, el))
# Invert sign of target vector, as positive dot product with baseline implies negative delay / advance
# Augment target vector with a 1 to be 4-dimensional, as this allows fitting of constant (receiver) delay
# This array has shape (4, T), with the augmented target vectors as columns
scan_augmented_targetdir = np.vstack((-targetdir, np.ones(len(el))))
# Create section of design matrix with shape (B P, T), by inserting target dir vectors in right places
augm_block = np.dot(bl_parameter_map, scan_augmented_targetdir)
# Rearrange shape to (P, B T) to be compatible with ravelled delay data, which has shape (B T,)
augm_block = augm_block.reshape(num_bls, num_params, num_ts).swapaxes(0, 1).reshape(num_params, -1)
augmented_targetdir.append(augm_block)
# Group delay is proportional to phase slope across the band - estimate this as the phase difference between
# consecutive frequency channels calculated via np.diff. Pick antenna 1 as reference antenna -> correlation
# product XY* means we actually measure phase(antenna1) - phase(antenna2), therefore flip the sign.
# Also divide by channel frequency difference, which correctly handles gaps in frequency coverage.
phase_diff_per_Hz = np.diff(-np.angle(vis), axis=1) / freq_diff[:, np.newaxis]
# Convert to a delay in seconds