def generate_uvw_coords_m(x, y, z, obs_length_h, mjd_mid, t_acc, ra, dec,
filename=None):
num_times = int((obs_length_h * 3600.0) / t_acc)
mjd_start = mjd_mid - ((obs_length_h / 2) / 24)
num_baselines = x.shape[0] * (x.shape[0] - 1) // 2
num_vis = num_baselines * num_times
uu, vv, ww = np.zeros(num_vis), np.zeros(num_vis), np.zeros(num_vis)
print('- Simulating uv coordinates for %i times over %.1f h'
% (num_times, obs_length_h))
t0 = time.time()
for i in range(num_times):
mjd = mjd_start + (i * t_acc + t_acc / 2) / 86400
uu_, vv_, ww_ = evaluate_baseline_uvw(x, y, z, ra, dec, mjd)
uu[i * num_baselines:(i + 1) * num_baselines] = uu_
vv[i * num_baselines:(i + 1) * num_baselines] = vv_
ww[i * num_baselines:(i + 1) * num_baselines] = ww_
print('- Generated uv %i coordinates in %.2f s'
% (uu.shape[0], time.time() - t0))
if filename:
dir_name = os.path.dirname(filename)
if not os.path.isdir(dir_name):
os.makedirs(dir_name)
plot_uv_coords(uu, vv, filename=filename + '_all')
plot_uv_coords(uu, vv, filename=filename + '_r%06.1fm' % 100.0,
r_lim=100.0)
return uu, vv, ww, num_times
def generate_uvw_coords_m(x,
y,
z,
obs_length_h,
mjd_mid,
t_acc,
ra,
dec,
filename=None):
num_times = int((obs_length_h * 3600.0) / t_acc)
mjd_start = mjd_mid - ((obs_length_h / 2) / 24)
num_baselines = x.shape[0] * (x.shape[0] - 1) // 2
num_vis = num_baselines * num_times
uu, vv, ww = np.zeros(num_vis), np.zeros(num_vis), np.zeros(num_vis)
print('- Simulating uv coordinates for %i times over %.1f h' %
(num_times, obs_length_h))
t0 = time.time()
for i in range(num_times):
mjd = mjd_start + (i * t_acc + t_acc / 2) / 86400
uu_, vv_, ww_ = evaluate_baseline_uvw(x, y, z, ra, dec, mjd)
uu[i * num_baselines:(i + 1) * num_baselines] = uu_
vv[i * num_baselines:(i + 1) * num_baselines] = vv_
ww[i * num_baselines:(i + 1) * num_baselines] = ww_
print('- Generated uv %i coordinates in %.2f s' %
(uu.shape[0], time.time() - t0))
if filename:
dir_name = os.path.dirname(filename)
if not os.path.isdir(dir_name):
os.makedirs(dir_name)
plot_uv_coords(uu, vv, filename=filename + '_all')
plot_uv_coords(uu,
vv,
filename=filename + '_r%06.1fm' % 100.0,
r_lim=100.0)
return uu, vv, ww, num_times
def generate_baseline_coordinates(layout, settings):
"""Generate baseline coordinates"""
x, y = layout['x'], layout['y']
wavelength_m = 299792458.0 / settings['freq_hz']
mjd_start = settings['mjd_mid'] - (settings['obs_length_s'] / 2.0) / 86400.0
x, y, z = np.array(x), np.array(y), np.zeros_like(x)
x_ecef, y_ecef, z_ecef = convert_enu_to_ecef(x, y, z, settings['lon'],
settings['lat'])
x_c, y_c, z_c = convert_enu_to_ecef([0.0], [0.0], [0.0], settings['lon'],
settings['lat'])
x_ecef -= x_c
y_ecef -= y_c
z_ecef -= z_c
num_stations = x_ecef.shape[0]
num_baselines = num_stations * (num_stations - 1) / 2
num_coords = settings['num_times'] * num_baselines
uu = np.zeros(num_coords, dtype='f4')
vv, ww = np.zeros_like(uu), np.zeros_like(uu)
u = np.zeros(num_stations, dtype='f4')
v, w = np.zeros_like(u), np.zeros_like(u)
for i in range(settings['num_times']):
mjd = mjd_start + (i * settings['interval_s'] +
settings['interval_s'] / 2.0) / 86400.0
uu_, vv_, ww_ = evaluate_baseline_uvw(x_ecef, y_ecef, z_ecef,
settings['ra'], settings['dec'],
mjd)
u, v, w = evaluate_station_uvw(x_ecef, y_ecef, z_ecef, settings['ra'],
settings['dec'], mjd)
uu[i * num_baselines: (i + 1) * num_baselines] = uu_ / wavelength_m
vv[i * num_baselines: (i + 1) * num_baselines] = vv_ / wavelength_m
ww[i * num_baselines: (i + 1) * num_baselines] = ww_ / wavelength_m
return uu, vv, ww, u, w, v
def generate_baseline_uvw(x, y, z, ra_rad, dec_rad, num_times, num_baselines,
mjd_start, dt_s):
num_coords = num_times * num_baselines
uu = numpy.zeros(num_coords, dtype='f8')
vv = numpy.zeros(num_coords, dtype='f8')
ww = numpy.zeros(num_coords, dtype='f8')
for i in range(num_times):
t = i * dt_s + dt_s / 2.0
mjd = mjd_start + (t / 86400.0)
i0 = i * num_baselines
i1 = i0 + num_baselines
uu_, vv_, ww_ = evaluate_baseline_uvw(x, y, z, ra_rad, dec_rad, mjd)
uu[i0:i1] = uu_
vv[i0:i1] = vv_
ww[i0:i1] = ww_
return uu, vv, ww
def generate_baseline_uvw(x, y, z, ra_rad, dec_rad, num_times, mjd_start, dt_s):
"""Generate baseline coordinates from ecef station coordinates."""
num_stations = x.shape[0]
num_baselines = num_stations * (num_stations - 1) / 2
num_coords = num_times * num_baselines
uu = numpy.zeros(num_coords, dtype='f8')
vv = numpy.zeros(num_coords, dtype='f8')
ww = numpy.zeros(num_coords, dtype='f8')
for i in range(num_times):
t = i * dt_s + dt_s / 2.0
mjd = mjd_start + (t / 86400.0)
i0 = i * num_baselines
i1 = i0 + num_baselines
uu_, vv_, ww_ = evaluate_baseline_uvw(x, y, z, ra_rad, dec_rad, mjd)
uu[i0:i1] = uu_
vv[i0:i1] = vv_
ww[i0:i1] = ww_
return uu, vv, ww
def generate_uv_coords(x_ecef, y_ecef, z_ecef, settings, obs):
wavelength_m = 299792458.0 / settings['freq_hz']
mjd_start = settings['mjd_mid'] - (obs['obs_length_s'] / 2.0) / 86400.0
num_stations = x_ecef.shape[0]
num_baselines = num_stations * (num_stations - 1) / 2
num_coords = obs['num_times'] * num_baselines
uu = numpy.zeros(num_coords, dtype='f4')
vv = numpy.zeros_like(uu, dtype='f4')
ww = numpy.zeros_like(uu, dtype='f4')
for i in range(obs['num_times']):
mjd = mjd_start + (i * obs['interval_s'] +
obs['interval_s'] / 2.0) / 86400.0
uu_, vv_, ww_ = pyuvwsim.evaluate_baseline_uvw(x_ecef, y_ecef, z_ecef,
settings['ra'],
settings['dec'], mjd)
uu[i * num_baselines: (i + 1) * num_baselines] = uu_ / wavelength_m
vv[i * num_baselines: (i + 1) * num_baselines] = vv_ / wavelength_m
ww[i * num_baselines: (i + 1) * num_baselines] = ww_ / wavelength_m
return uu, vv, ww
def generate_baseline_coords(layout, settings):
x, y = layout['x'], layout['y']
z = numpy.zeros_like(x)
wavelength_m = 299792458.0 / settings['freq_hz']
mjd_start = settings['mjd_mid'] - (settings['obs_length_s'] / 2.0) / 86400.0
x, y, z = numpy.array(x), numpy.array(y), numpy.zeros_like(x)
x_ecef, y_ecef, z_ecef = pyuvwsim.convert_enu_to_ecef(x, y, z,
settings['lon'],
settings['lat'])
num_stations = x_ecef.shape[0]
num_baselines = num_stations * (num_stations - 1) / 2
num_coords = settings['num_times'] * num_baselines
uu = numpy.zeros(num_coords, dtype='f4')
vv, ww = numpy.zeros_like(uu), numpy.zeros_like(uu)
for i in range(settings['num_times']):
mjd = mjd_start + (i * settings['interval_s'] +
settings['interval_s'] / 2.0) / 86400.0
uu_, vv_, ww_ = pyuvwsim.evaluate_baseline_uvw(x_ecef, y_ecef, z_ecef,
settings['ra'],
settings['dec'], mjd)
uu[i * num_baselines: (i + 1) * num_baselines] = uu_ / wavelength_m
vv[i * num_baselines: (i + 1) * num_baselines] = vv_ / wavelength_m
ww[i * num_baselines: (i + 1) * num_baselines] = ww_ / wavelength_m
return uu, vv, ww
lat = 90.0 * (np.pi/180.)
alt = 0.0
ra0 = 0.0 * (np.pi/180.)
dec0 = 90.0 * (np.pi/180.)
ntimes = 10
obs_length = 0.2 # days
# ---------------------------------------------------------
# Generate coordinates.
mjd_start = uvw.datetime_to_mjd(2014, 7, 28, 14, 26, 1.321);
(x,y,z) = uvw.load_station_coords(filename)
(x,y,z) = uvw.convert_enu_to_ecef(x, y, z, lon, lat, alt)
t0 = time.time()
for i in range(0, ntimes):
mjd = mjd_start
(uu_m,vv_m,ww_m) = uvw.evaluate_baseline_uvw(x,y,z, ra0, dec0, mjd)
print '- Time taken to evaluate uww coordinates = %.3f ms' % ((time.time()-t0)*1.e3)
# Scatter plot of baseline coordinates.
plt.ioff()
plt_filename = 'test.png'
fig = plt.figure(figsize=(6,6))
matplotlib.rcParams.update({'font.size': 10})
scatter_size = 3
fig.add_subplot(1,1,1, aspect='equal')
plt.scatter(uu_m, vv_m, c='b', lw = 0, s=scatter_size);
plt.scatter(-uu_m, -vv_m, c='r', lw = 0, s=scatter_size);
plt.xlabel('uu [metres]', fontsize=8)
plt.ylabel('vv [metres]', fontsize=8)
plt.title(filename[-17:])
plt.grid(True)
def simulate_2(config):
"""Simulate with and without corruptions followed by averaging.
Simulation to be performed in blocks due to memory constraints.
"""
telescope = config['sim']['telescope']
obs = config['sim']['observation']
corrupt = config['corrupt']
freq_hz = obs['freq_hz']
wavelength = 299792458.0 / freq_hz
lon = math.radians(telescope['lon_deg'])
lat = math.radians(telescope['lat_deg'])
alt = telescope['alt_m']
ra = math.radians(obs['ra_deg'])
dec = math.radians(obs['dec_deg'])
mjd_start = obs['start_time_mjd']
num_dumps = obs['num_times']
dump_time_s = obs['dump_time_s']
over_sample = obs['over_sample']
dt_s = dump_time_s / over_sample
num_times = num_dumps * over_sample
telescope_model = telescope['path']
x, y, z = load_station_coords(join(telescope_model, 'layout.txt'))
x, y, z = convert_enu_to_ecef(x, y, z, lon, lat, alt)
num_antennas = x.shape[0]
num_baselines = num_antennas * (num_antennas - 1) / 2
num_vis = num_dumps * num_baselines
sky_model = config['sim']['sky_file']
sky = numpy.loadtxt(sky_model, delimiter=',')
sky = sky.reshape((-1, 3))
num_sources = sky.shape[0]
source_ra = numpy.radians(sky[:, 0])
source_dec = numpy.radians(sky[:, 1])
l, m, n = convert_ra_dec_to_relative_directions(
source_ra, source_dec, ra, dec)
tau = corrupt['tau_s']
hurst_amp = corrupt['amplitude']['hurst']
adev_amp = corrupt['amplitude']['allan_dev']
std_t_mid_amp = corrupt['amplitude']['std_t_mid']
hurst_phase = corrupt['phase']['hurst']
adev_phase = corrupt['phase']['allan_dev']
std_t_mid_phase = corrupt['phase']['std_t_mid']
smoothing_length = corrupt['smoothing_length']
print('- Simulating data...')
print(' - No. antennas :', num_antennas)
print(' - No. baselines :', num_baselines)
print(' - Obs. length : %.1f s' % (num_dumps * dump_time_s))
print(' - No. times : %i (no. dumps: %i, over-sample: %i)' %
(num_times, num_dumps, over_sample))
print(' - No. vis :', num_vis)
print(' - No. sources :', num_sources)
print(' - Corruptions:')
print(' - Hurst amp %.1f, phase %.1f' % (hurst_amp, hurst_phase))
print(' - A. dev amp %.1e, phase %.1e' % (adev_amp, adev_phase))
num_bytes = num_vis * 8 * 8 + (num_antennas * num_times) * 16
mem = virtual_memory()
print(' - Mem. required : %.1f / %.1f MB' %
(num_bytes / 1024.0**2, mem.total / 1024.0**2))
if num_bytes >= mem.total:
raise RuntimeError('Not enough system memory for requested '
'simulation.')
# Generate corruptions
gains = numpy.empty((num_antennas, num_times), dtype='c16')
t0 = time.time()
for i in range(num_antennas):
gains[i, :] = eval_complex_gains(num_times, dt_s, hurst_amp, adev_amp,
std_t_mid_amp, hurst_phase, adev_phase,
std_t_mid_phase, smoothing_length,
tau)
conj_gains = numpy.conj(gains)
print(' - Gains generated in %.1f s' % (time.time() - t0))
# TODO-BM plot the gains ...
# Simulation
phase0 = 2.0 * math.pi / wavelength
model = numpy.empty(num_vis, dtype='c16')
data = numpy.empty(num_vis, dtype='c16')
weight = numpy.ones(num_vis, dtype='f8')
block_model = numpy.empty((over_sample, num_baselines), dtype='c16')
block_data = numpy.empty((over_sample, num_baselines), dtype='c16')
t1 = time.time()
# Loop over correlator dumps
for i in range(num_dumps):
block_model.fill(0.0 + 0.0j)
block_data.fill(0.0 + 0.0j)
# Loop over times in a dump.
for t in range(over_sample):
delta_t = (i * dump_time_s) + (t * dt_s) + (dt_s / 2.0)
mjd = mjd_start + (delta_t / 86400.0)
uu_, vv_, ww_ = evaluate_baseline_uvw(x, y, z, ra, dec, mjd)
for s in range(num_sources):
phase = phase0 * (uu_ * l[s] + vv_ * m[s] + ww_ * (n[s] - 1.0))
block_model[t, :] += numpy.exp(1.0j * phase)
ig = i * over_sample + t
block_data[t, :] = apply_gains(block_model[t, :], gains[:, ig])
# data_ = apply_gains(block_model[t, :], gains[:, ig])
# idx = 0
# for p in range(num_antennas):
# for q in range(p + 1, num_antennas):
# gp = gains[p, ig]
# gq = conj_gains[q, ig]
# block_data[t, idx] = gp * block_model[t, idx] * gq
# idx += 1
# if i < 3:
# print('t[%02i]' % t)
# print(' C:', data_[0])
# print(' P:', block_data[t, 0])
# print(' D:', numpy.max(numpy.abs(data_[:] - block_data[t, :])))
# assert numpy.max(numpy.abs(data_[:] - block_data[t, :])) == 0.0
# Average the block to get visibility data amplitudes for the dump.
b0 = i * num_baselines
b1 = b0 + num_baselines
model[b0:b1] = numpy.mean(block_model, axis=0)
data[b0:b1] = numpy.mean(block_data, axis=0)
uu, vv, ww = generate_baseline_uvw(x, y, z, ra, dec, num_dumps,
num_baselines, mjd_start, dump_time_s)
print(' - Visibilities simulated in %.2f s' % (time.time() - t1))
return {'model': model, 'data': data, 'uu': uu, 'vv': vv, 'ww': ww,
'weight': weight, 'num_baselines': num_baselines,
'num_times': num_dumps, 'num_antennas': num_antennas}
lat = 90.0 * (np.pi / 180.)
alt = 0.0
ra0 = 0.0 * (np.pi / 180.)
dec0 = 90.0 * (np.pi / 180.)
ntimes = 10
obs_length = 0.2 # days
# ---------------------------------------------------------
# Generate coordinates.
mjd_start = uvw.datetime_to_mjd(2014, 7, 28, 14, 26, 1.321)
(x, y, z) = uvw.load_station_coords(filename)
(x, y, z) = uvw.convert_enu_to_ecef(x, y, z, lon, lat, alt)
t0 = time.time()
for i in range(0, ntimes):
mjd = mjd_start
(uu_m, vv_m, ww_m) = uvw.evaluate_baseline_uvw(x, y, z, ra0, dec0, mjd)
print '- Time taken to evaluate uww coordinates = %.3f ms' % (
(time.time() - t0) * 1.e3)
# Scatter plot of baseline coordinates.
plt.ioff()
plt_filename = 'test.png'
fig = plt.figure(figsize=(6, 6))
matplotlib.rcParams.update({'font.size': 10})
scatter_size = 3
fig.add_subplot(1, 1, 1, aspect='equal')
plt.scatter(uu_m, vv_m, c='b', lw=0, s=scatter_size)
plt.scatter(-uu_m, -vv_m, c='r', lw=0, s=scatter_size)
plt.xlabel('uu [metres]', fontsize=8)
plt.ylabel('vv [metres]', fontsize=8)
plt.title(filename[-17:])