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:])