TEST(Mem, set_value_real_double_complex_matrix)
{
// Double precision complex matrix.
int n = 100, status = 0;
oskar_Mem *mem, *mem2;
mem = oskar_mem_create(OSKAR_DOUBLE_COMPLEX_MATRIX, OSKAR_GPU, n,
&status);
oskar_mem_set_value_real(mem, 6.5, 0, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
mem2 = oskar_mem_create_copy(mem, OSKAR_CPU, &status);
double4c* v = oskar_mem_double4c(mem2, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
for (int i = 0; i < n; ++i)
{
EXPECT_DOUBLE_EQ(v[i].a.x, 6.5);
EXPECT_DOUBLE_EQ(v[i].a.y, 0.0);
EXPECT_DOUBLE_EQ(v[i].b.x, 0.0);
EXPECT_DOUBLE_EQ(v[i].b.y, 0.0);
EXPECT_DOUBLE_EQ(v[i].c.x, 0.0);
EXPECT_DOUBLE_EQ(v[i].c.y, 0.0);
EXPECT_DOUBLE_EQ(v[i].d.x, 6.5);
EXPECT_DOUBLE_EQ(v[i].d.y, 0.0);
}
oskar_mem_free(mem, &status);
oskar_mem_free(mem2, &status);
}
void oskar_telescope_load_position(oskar_Telescope* telescope,
const char* filename, int* status)
{
int num_coords;
oskar_Mem *lon, *lat, *alt;
/* Load columns from file. */
lon = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, status);
lat = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, status);
alt = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, status);
num_coords = (int) oskar_mem_load_ascii(filename, 3, status,
lon, "", lat, "", alt, "0.0");
/* Set the telescope centre coordinates. */
if (num_coords == 1)
{
telescope->lon_rad = (oskar_mem_double(lon, status))[0] * M_PI / 180.0;
telescope->lat_rad = (oskar_mem_double(lat, status))[0] * M_PI / 180.0;
telescope->alt_metres = (oskar_mem_double(alt, status))[0];
}
else
{
*status = OSKAR_ERR_BAD_COORD_FILE;
}
/* Free memory. */
oskar_mem_free(lon, status);
oskar_mem_free(lat, status);
oskar_mem_free(alt, status);
}
static void free_device_data(oskar_Simulator* h, int* status)
{
int i;
if (!h->d) return;
for (i = 0; i < h->num_devices; ++i)
{
DeviceData* d = &(h->d[i]);
if (!d) continue;
if (i < h->num_gpus)
oskar_device_set(h->gpu_ids[i], status);
oskar_timer_free(d->tmr_compute);
oskar_timer_free(d->tmr_copy);
oskar_timer_free(d->tmr_clip);
oskar_timer_free(d->tmr_E);
oskar_timer_free(d->tmr_K);
oskar_timer_free(d->tmr_join);
oskar_timer_free(d->tmr_correlate);
oskar_vis_block_free(d->vis_block_cpu[0], status);
oskar_vis_block_free(d->vis_block_cpu[1], status);
oskar_vis_block_free(d->vis_block, status);
oskar_mem_free(d->u, status);
oskar_mem_free(d->v, status);
oskar_mem_free(d->w, status);
oskar_sky_free(d->chunk, status);
oskar_sky_free(d->chunk_clip, status);
oskar_telescope_free(d->tel, status);
oskar_station_work_free(d->station_work, status);
oskar_jones_free(d->J, status);
oskar_jones_free(d->E, status);
oskar_jones_free(d->K, status);
oskar_jones_free(d->R, status);
memset(d, 0, sizeof(DeviceData));
}
}
TEST(Mem, random_gaussian_accum)
{
int status = 0;
int seed = 1;
int blocksize = 256;
int rounds = 10240;
oskar_Mem* block = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
blocksize, &status);
oskar_Mem* total = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
blocksize * rounds, &status);
for (int i = 0; i < rounds; ++i)
{
oskar_mem_random_gaussian(block, seed, i, 0, 0, 1.0, &status);
oskar_mem_copy_contents(total, block,
i * blocksize, 0, blocksize, &status);
}
ASSERT_EQ(0, status) << oskar_get_error_string(status);
if (save)
{
FILE* fhan = fopen("random_gaussian_accum.txt", "w");
oskar_mem_save_ascii(fhan, 1, blocksize * rounds, &status, total);
fclose(fhan);
}
oskar_mem_free(block, &status);
oskar_mem_free(total, &status);
}
void oskar_imager_free(oskar_Imager* h, int* status)
{
int i;
if (!h) return;
oskar_imager_reset_cache(h, status);
oskar_mem_free(h->uu_im, status);
oskar_mem_free(h->vv_im, status);
oskar_mem_free(h->ww_im, status);
oskar_mem_free(h->uu_tmp, status);
oskar_mem_free(h->vv_tmp, status);
oskar_mem_free(h->ww_tmp, status);
oskar_mem_free(h->vis_im, status);
oskar_mem_free(h->weight_im, status);
oskar_mem_free(h->weight_tmp, status);
oskar_mem_free(h->time_im, status);
oskar_timer_free(h->tmr_grid_finalise);
oskar_timer_free(h->tmr_grid_update);
oskar_timer_free(h->tmr_init);
oskar_timer_free(h->tmr_read);
oskar_timer_free(h->tmr_write);
oskar_mutex_free(h->mutex);
oskar_imager_free_device_data(h, status);
for (i = 0; i < h->num_files; ++i)
free(h->input_files[i]);
free(h->input_files);
free(h->input_root);
free(h->output_root);
free(h->ms_column);
free(h->gpu_ids);
free(h->d);
free(h);
}
oskar_Mem* oskar_mem_read_binary_raw(const char* filename, int type,
int location, int* status)
{
size_t num_elements, element_size, size_bytes;
oskar_Mem *mem = 0;
FILE* stream;
/* Check if safe to proceed. */
if (*status) return 0;
/* Open the input file. */
stream = fopen(filename, "rb");
if (!stream)
{
*status = OSKAR_ERR_FILE_IO;
return 0;
}
/* Get the file size. */
fseek(stream, 0, SEEK_END);
size_bytes = ftell(stream);
/* Create memory block of the right size. */
element_size = oskar_mem_element_size(type);
num_elements = (size_t)ceil(size_bytes / element_size);
mem = oskar_mem_create(type, OSKAR_CPU, num_elements, status);
if (*status)
{
oskar_mem_free(mem, status);
fclose(stream);
return 0;
}
/* Read the data. */
fseek(stream, 0, SEEK_SET);
if (fread(oskar_mem_void(mem), 1, size_bytes, stream) != size_bytes)
{
oskar_mem_free(mem, status);
fclose(stream);
*status = OSKAR_ERR_FILE_IO;
return 0;
}
/* Close the input file. */
fclose(stream);
/* Copy to GPU memory if required. */
if (location != OSKAR_CPU)
{
oskar_Mem* gpu;
gpu = oskar_mem_create_copy(mem, location, status);
oskar_mem_free(mem, status);
return gpu;
}
return mem;
}
int benchmark(int num_elements, int num_directions, OpType op_type,
int loc, int precision, bool evaluate_2d, int niter, double& time_taken)
{
int status = 0;
int type = precision | OSKAR_COMPLEX;
oskar_Mem *beam = 0, *signal = 0, *z = 0, *z_i = 0;
oskar_Mem *x = oskar_mem_create(precision, loc, num_directions, &status);
oskar_Mem *y = oskar_mem_create(precision, loc, num_directions, &status);
oskar_Mem *x_i = oskar_mem_create(precision, loc, num_elements, &status);
oskar_Mem *y_i = oskar_mem_create(precision, loc, num_elements, &status);
oskar_Mem *weights = oskar_mem_create(type, loc, num_elements, &status);
if (!evaluate_2d)
{
z = oskar_mem_create(precision, loc, num_directions, &status);
z_i = oskar_mem_create(precision, loc, num_elements, &status);
}
if (op_type == O2C)
beam = oskar_mem_create(type, loc, num_directions, &status);
else if (op_type == C2C || op_type == M2M)
{
int num_signals = num_directions * num_elements;
if (op_type == C2C)
{
beam = oskar_mem_create(type, loc, num_directions, &status);
signal = oskar_mem_create(type, loc, num_signals, &status);
}
else
{
type |= OSKAR_MATRIX;
beam = oskar_mem_create(type, loc, num_directions, &status);
signal = oskar_mem_create(type, loc, num_signals, &status);
}
}
oskar_Timer *tmr = oskar_timer_create(OSKAR_TIMER_NATIVE);
if (!status)
{
oskar_timer_start(tmr);
for (int i = 0; i < niter; ++i)
{
oskar_dftw(num_elements, 2.0 * M_PI, x_i, y_i, z_i, weights,
num_directions, x, y, z, signal, beam, &status);
}
time_taken = oskar_timer_elapsed(tmr);
}
// Free memory.
oskar_timer_free(tmr);
oskar_mem_free(x, &status);
oskar_mem_free(y, &status);
oskar_mem_free(z, &status);
oskar_mem_free(x_i, &status);
oskar_mem_free(y_i, &status);
oskar_mem_free(z_i, &status);
oskar_mem_free(weights, &status);
oskar_mem_free(beam, &status);
oskar_mem_free(signal, &status);
return status;
}
void oskar_evaluate_station_beam_aperture_array(oskar_Mem* beam,
const oskar_Station* station, int num_points, const oskar_Mem* x,
const oskar_Mem* y, const oskar_Mem* z, double gast,
double frequency_hz, oskar_StationWork* work, int time_index,
int* status)
{
int start;
/* Check if safe to proceed. */
if (*status) return;
/* Evaluate beam immediately, without chunking, if there are no
* child stations. */
if (!oskar_station_has_child(station))
{
oskar_evaluate_station_beam_aperture_array_private(beam, station,
num_points, x, y, z, gast, frequency_hz, work,
time_index, 0, status);
}
else
{
oskar_Mem *c_beam, *c_x, *c_y, *c_z;
c_beam = oskar_mem_create_alias(0, 0, 0, status);
c_x = oskar_mem_create_alias(0, 0, 0, status);
c_y = oskar_mem_create_alias(0, 0, 0, status);
c_z = oskar_mem_create_alias(0, 0, 0, status);
/* Split up list of input points into manageable chunks. */
for (start = 0; start < num_points; start += MAX_CHUNK_SIZE)
{
int chunk_size;
/* Get size of current chunk. */
chunk_size = num_points - start;
if (chunk_size > MAX_CHUNK_SIZE) chunk_size = MAX_CHUNK_SIZE;
/* Get pointers to start of chunk input data. */
oskar_mem_set_alias(c_beam, beam, start, chunk_size, status);
oskar_mem_set_alias(c_x, x, start, chunk_size, status);
oskar_mem_set_alias(c_y, y, start, chunk_size, status);
oskar_mem_set_alias(c_z, z, start, chunk_size, status);
/* Start recursive call at depth 1 (depth 0 is element level). */
oskar_evaluate_station_beam_aperture_array_private(c_beam, station,
chunk_size, c_x, c_y, c_z, gast, frequency_hz, work,
time_index, 1, status);
}
/* Release handles for chunk memory. */
oskar_mem_free(c_beam, status);
oskar_mem_free(c_x, status);
oskar_mem_free(c_y, status);
oskar_mem_free(c_z, status);
}
}
void destroyTestData()
{
int status = 0;
oskar_jones_free(jones, &status);
oskar_mem_free(u_, &status);
oskar_mem_free(v_, &status);
oskar_mem_free(w_, &status);
oskar_sky_free(sky, &status);
oskar_telescope_free(tel, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
}
void oskar_fft_free(oskar_FFT* h)
{
int status = 0;
if (!h) return;
oskar_mem_free(h->fftpack_work, &status);
oskar_mem_free(h->fftpack_wsave, &status);
#ifdef OSKAR_HAVE_CUDA
if (h->location == OSKAR_GPU)
cufftDestroy(h->cufft_plan);
#endif
free(h);
}
TEST(element_weights_errors, test_evaluate)
{
int num_elements = 10000;
double element_gain = 1.0;
double element_gain_error = 0.0;
double element_phase = 0.0 * M_PI;
double element_phase_error = 0.0 * M_PI;
int error = 0;
unsigned int seed = 1;
oskar_Mem *d_gain, *d_gain_error, *d_phase, *d_phase_error, *d_errors;
d_gain = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &error);
d_gain_error = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &error);
d_phase = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &error);
d_phase_error = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &error);
d_errors = oskar_mem_create(OSKAR_DOUBLE_COMPLEX, OSKAR_GPU,
num_elements, &error);
ASSERT_EQ(0, error) << oskar_get_error_string(error);
oskar_mem_set_value_real(d_gain, element_gain, 0, 0, &error);
oskar_mem_set_value_real(d_gain_error, element_gain_error, 0, 0, &error);
oskar_mem_set_value_real(d_phase, element_phase, 0, 0, &error);
oskar_mem_set_value_real(d_phase_error, element_phase_error, 0, 0, &error);
oskar_mem_set_value_real(d_errors, 0.0, 0, 0, &error);
ASSERT_EQ(0, error) << oskar_get_error_string(error);
// Evaluate weights errors.
oskar_evaluate_element_weights_errors(num_elements,
d_gain, d_gain_error, d_phase, d_phase_error,
seed, 0, 0, d_errors, &error);
ASSERT_EQ(0, error) << oskar_get_error_string(error);
// Write memory to file for inspection.
const char* fname = "temp_test_element_errors.dat";
FILE* file = fopen(fname, "w");
oskar_mem_save_ascii(file, 5, num_elements, &error,
d_gain, d_gain_error, d_phase, d_phase_error, d_errors);
fclose(file);
remove(fname);
// Free memory.
oskar_mem_free(d_gain, &error);
oskar_mem_free(d_gain_error, &error);
oskar_mem_free(d_phase, &error);
oskar_mem_free(d_phase_error, &error);
oskar_mem_free(d_errors, &error);
ASSERT_EQ(0, error) << oskar_get_error_string(error);
}
int benchmark(int num_stations, int num_sources, int type,
int jones_type, int loc, int use_extended, int use_time_ave, int niter,
std::vector<double>& times)
{
int status = 0;
oskar_Timer* timer;
timer = oskar_timer_create(loc == OSKAR_GPU ?
OSKAR_TIMER_CUDA : OSKAR_TIMER_OMP);
// Set up a test sky model, telescope model and Jones matrices.
oskar_Telescope* tel = oskar_telescope_create(type, loc,
num_stations, &status);
oskar_Sky* sky = oskar_sky_create(type, loc, num_sources, &status);
oskar_Jones* J = oskar_jones_create(jones_type, loc, num_stations,
num_sources, &status);
oskar_telescope_set_channel_bandwidth(tel, 1e6);
oskar_telescope_set_time_average(tel, (double) use_time_ave);
oskar_sky_set_use_extended(sky, use_extended);
// Memory for visibility coordinates and output visibility slice.
oskar_Mem *vis, *u, *v, *w;
vis = oskar_mem_create(jones_type, loc, oskar_telescope_num_baselines(tel),
&status);
u = oskar_mem_create(type, loc, num_stations, &status);
v = oskar_mem_create(type, loc, num_stations, &status);
w = oskar_mem_create(type, loc, num_stations, &status);
// Run benchmark.
times.resize(niter);
for (int i = 0; i < niter; ++i)
{
oskar_timer_start(timer);
oskar_cross_correlate(vis, oskar_sky_num_sources(sky), J, sky, tel, u, v, w,
0.0, 100e6, &status);
times[i] = oskar_timer_elapsed(timer);
}
// Free memory.
oskar_mem_free(u, &status);
oskar_mem_free(v, &status);
oskar_mem_free(w, &status);
oskar_mem_free(vis, &status);
oskar_jones_free(J, &status);
oskar_telescope_free(tel, &status);
oskar_sky_free(sky, &status);
oskar_timer_free(timer);
return status;
}
TEST(Mem, stats)
{
int status = 0;
oskar_Mem* values;
values = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 5, &status);
// Fill an array with the values 1, 2, 3, 4, 5.
double *v = oskar_mem_double(values, &status);
v[0] = 1.0;
v[1] = 2.0;
v[2] = 3.0;
v[3] = 4.0;
v[4] = 5.0;
// Compute minimum, maximum, mean and population standard deviation.
double min, max, mean, std_dev;
oskar_mem_stats(values, oskar_mem_length(values), &min, &max, &mean,
&std_dev, &status);
// Check values are correct.
ASSERT_DOUBLE_EQ(3.0, mean);
ASSERT_DOUBLE_EQ(1.0, min);
ASSERT_DOUBLE_EQ(5.0, max);
ASSERT_DOUBLE_EQ(sqrt(2.0), std_dev);
// Free memory.
oskar_mem_free(values, &status);
}
void oskar_interferometer_free(oskar_Interferometer* h, int* status)
{
int i;
if (!h) return;
oskar_interferometer_reset_cache(h, status);
for (i = 0; i < h->num_gpus; ++i)
{
oskar_device_set(h->gpu_ids[i], status);
oskar_device_reset();
}
for (i = 0; i < h->num_sky_chunks; ++i)
oskar_sky_free(h->sky_chunks[i], status);
oskar_telescope_free(h->tel, status);
oskar_mem_free(h->temp, status);
oskar_timer_free(h->tmr_sim);
oskar_timer_free(h->tmr_write);
oskar_mutex_free(h->mutex);
oskar_barrier_free(h->barrier);
free(h->sky_chunks);
free(h->gpu_ids);
free(h->vis_name);
free(h->ms_name);
free(h->settings_path);
free(h->d);
free(h);
}
void oskar_telescope_set_noise_freq(oskar_Telescope* model,
double start_hz, double inc_hz, int num_channels, int* status)
{
int i;
oskar_Mem* noise_freq_hz;
noise_freq_hz = oskar_mem_create(model->precision, OSKAR_CPU,
num_channels, status);
if (*status) return;
if (model->precision == OSKAR_DOUBLE)
{
double* f = oskar_mem_double(noise_freq_hz, status);
for (i = 0; i < num_channels; ++i) f[i] = start_hz + i * inc_hz;
}
else
{
float* f = oskar_mem_float(noise_freq_hz, status);
for (i = 0; i < num_channels; ++i) f[i] = start_hz + i * inc_hz;
}
/* Set noise frequency for all top-level stations. */
for (i = 0; i < model->num_stations; ++i)
{
oskar_Mem* t;
t = oskar_station_noise_freq_hz(model->station[i]);
oskar_mem_realloc(t, num_channels, status);
oskar_mem_copy(t, noise_freq_hz, status);
}
oskar_mem_free(noise_freq_hz, status);
}
void oskar_work_jones_z_free(oskar_WorkJonesZ* work, int* status)
{
oskar_mem_free(work->hor_x, status);
oskar_mem_free(work->hor_y, status);
oskar_mem_free(work->hor_z, status);
oskar_mem_free(work->pp_lon, status);
oskar_mem_free(work->pp_lat, status);
oskar_mem_free(work->pp_rel_path, status);
oskar_mem_free(work->screen_TEC, status);
oskar_mem_free(work->total_TEC, status);
free(work);
}
TEST(Mem, set_value_real_single_complex)
{
// Single precision complex.
int n = 100, status = 0;
oskar_Mem *mem, *mem2;
mem = oskar_mem_create(OSKAR_SINGLE_COMPLEX, OSKAR_GPU, n,
&status);
oskar_mem_set_value_real(mem, 6.5, 0, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
mem2 = oskar_mem_create_copy(mem, OSKAR_CPU, &status);
float2* v = oskar_mem_float2(mem2, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
for (int i = 0; i < n; ++i)
{
EXPECT_FLOAT_EQ(v[i].x, 6.5);
EXPECT_FLOAT_EQ(v[i].y, 0.0);
}
oskar_mem_free(mem, &status);
oskar_mem_free(mem2, &status);
}
void oskar_fft_exec(oskar_FFT* h, oskar_Mem* data, int* status)
{
oskar_Mem *data_copy = 0, *data_ptr = data;
if (oskar_mem_location(data) != h->location)
{
data_copy = oskar_mem_create_copy(data, h->location, status);
data_ptr = data_copy;
}
if (h->location == OSKAR_CPU)
{
if (h->num_dim == 1)
{
*status = OSKAR_ERR_FUNCTION_NOT_AVAILABLE;
}
else if (h->num_dim == 2)
{
if (h->precision == OSKAR_DOUBLE)
oskar_fftpack_cfft2f(h->dim_size, h->dim_size, h->dim_size,
oskar_mem_double(data_ptr, status),
oskar_mem_double(h->fftpack_wsave, status),
oskar_mem_double(h->fftpack_work, status));
else
oskar_fftpack_cfft2f_f(h->dim_size, h->dim_size, h->dim_size,
oskar_mem_float(data_ptr, status),
oskar_mem_float(h->fftpack_wsave, status),
oskar_mem_float(h->fftpack_work, status));
/* This step not needed for W-kernel generation, so turn it off. */
if (h->ensure_consistent_norm)
oskar_mem_scale_real(data_ptr, (double)h->num_cells_total,
0, h->num_cells_total, status);
}
}
else if (h->location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
if (h->precision == OSKAR_DOUBLE)
cufftExecZ2Z(h->cufft_plan,
(cufftDoubleComplex*) oskar_mem_void(data_ptr),
(cufftDoubleComplex*) oskar_mem_void(data_ptr),
CUFFT_FORWARD);
else
cufftExecC2C(h->cufft_plan,
(cufftComplex*) oskar_mem_void(data_ptr),
(cufftComplex*) oskar_mem_void(data_ptr),
CUFFT_FORWARD);
#endif
}
else
*status = OSKAR_ERR_BAD_LOCATION;
if (oskar_mem_location(data) != h->location)
oskar_mem_copy(data, data_ptr, status);
oskar_mem_free(data_copy, status);
}
void oskar_telescope_load_station_coords_wgs84(oskar_Telescope* telescope,
const char* filename, double longitude, double latitude,
double altitude, int* status)
{
int num_stations;
oskar_Mem *lon_deg, *lat_deg, *alt_m;
/* Load columns from file into memory. */
lon_deg = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, status);
lat_deg = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, status);
alt_m = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, status);
num_stations = (int) oskar_mem_load_ascii(filename, 3, status,
lon_deg, "", lat_deg, "", alt_m, "0.0");
/* Set the station coordinates. */
oskar_telescope_set_station_coords_wgs84(telescope, longitude, latitude,
altitude, num_stations, lon_deg, lat_deg, alt_m, status);
/* Free memory. */
oskar_mem_free(lon_deg, status);
oskar_mem_free(lat_deg, status);
oskar_mem_free(alt_m, status);
}
TEST(Mem, type_check_double_complex)
{
int status = 0;
oskar_Mem *mem;
mem = oskar_mem_create(OSKAR_DOUBLE_COMPLEX, OSKAR_CPU, 0,
&status);
EXPECT_EQ((int)OSKAR_TRUE, oskar_mem_is_double(mem));
EXPECT_EQ((int)OSKAR_TRUE, oskar_mem_is_complex(mem));
EXPECT_EQ((int)OSKAR_TRUE, oskar_mem_is_scalar(mem));
EXPECT_EQ((int)OSKAR_TRUE, oskar_type_is_double(OSKAR_DOUBLE_COMPLEX));
EXPECT_EQ((int)OSKAR_TRUE, oskar_type_is_complex(OSKAR_DOUBLE_COMPLEX));
EXPECT_EQ((int)OSKAR_TRUE, oskar_type_is_scalar(OSKAR_DOUBLE_COMPLEX));
oskar_mem_free(mem, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
}
TEST(Mem, type_check_single)
{
int status = 0;
oskar_Mem *mem;
mem = oskar_mem_create(OSKAR_SINGLE, OSKAR_CPU, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
EXPECT_EQ((int)OSKAR_FALSE, oskar_mem_is_double(mem));
EXPECT_EQ((int)OSKAR_FALSE, oskar_mem_is_complex(mem));
EXPECT_EQ((int)OSKAR_TRUE, oskar_mem_is_scalar(mem));
EXPECT_EQ((int)OSKAR_FALSE, oskar_type_is_double(OSKAR_SINGLE));
EXPECT_EQ((int)OSKAR_FALSE, oskar_type_is_complex(OSKAR_SINGLE));
EXPECT_EQ((int)OSKAR_TRUE, oskar_type_is_scalar(OSKAR_SINGLE));
oskar_mem_free(mem, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
}
oskar_Mem* oskar_mem_create_copy_from_raw(void* ptr, int type, int location,
size_t num_elements, int* status)
{
oskar_Mem *m = 0, *t = 0;
if (*status) return 0;
/* Create the handles. */
m = oskar_mem_create(type, location, num_elements, status);
t = oskar_mem_create_alias_from_raw(ptr, type, location, num_elements,
status);
oskar_mem_copy(m, t, status);
oskar_mem_free(t, status);
/* Return a handle the structure .*/
return m;
}
int main(int argc, char** argv)
{
int status = 0;
oskar::OptionParser opt("oskar_convert_geodetic_to_ecef",
oskar_version_string());
opt.set_description("Converts geodetic longitude/latitude/altitude to "
"Cartesian ECEF coordinates. Assumes WGS84 ellipsoid.");
opt.add_required("input file", "Path to file containing input coordinates. "
"Angles must be in degrees.");
if (!opt.check_options(argc, argv))
return OSKAR_FAIL;
const char* filename = opt.get_arg();
// Load the input file.
oskar_Mem *lon = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, &status);
oskar_Mem *lat = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, &status);
oskar_Mem *alt = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, &status);
size_t num_points = oskar_mem_load_ascii(filename, 3, &status,
lon, "", lat, "", alt, "0.0");
oskar_mem_scale_real(lon, M_PI / 180.0, &status);
oskar_mem_scale_real(lat, M_PI / 180.0, &status);
// Convert coordinates.
oskar_Mem *x = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_points, &status);
oskar_Mem *y = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_points, &status);
oskar_Mem *z = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_points, &status);
oskar_convert_geodetic_spherical_to_ecef(num_points,
oskar_mem_double_const(lon, &status),
oskar_mem_double_const(lat, &status),
oskar_mem_double_const(alt, &status),
oskar_mem_double(x, &status),
oskar_mem_double(y, &status),
oskar_mem_double(z, &status));
// Print converted coordinates.
oskar_mem_save_ascii(stdout, 3, num_points, &status, x, y, z);
// Clean up.
oskar_mem_free(lon, &status);
oskar_mem_free(lat, &status);
oskar_mem_free(alt, &status);
oskar_mem_free(x, &status);
oskar_mem_free(y, &status);
oskar_mem_free(z, &status);
if (status)
{
oskar_log_error(0, oskar_get_error_string(status));
return status;
}
return 0;
}
TEST(Mem, set_value_real_single)
{
// Single precision real.
int n = 100, status = 0;
oskar_Mem *mem;
mem = oskar_mem_create(OSKAR_SINGLE, OSKAR_CPU, n, &status);
oskar_mem_set_value_real(mem, 4.5, 0, 0, &status);
float* v = oskar_mem_float(mem, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
for (int i = 0; i < n; ++i)
{
EXPECT_FLOAT_EQ(v[i], 4.5);
}
oskar_mem_free(mem, &status);
}
TEST(Mem, set_value_real_double)
{
// Double precision real.
int n = 100, status = 0;
oskar_Mem *mem;
mem = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, n, &status);
oskar_mem_set_value_real(mem, 4.5, 0, 0, &status);
double* v = oskar_mem_double(mem, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
for (int i = 0; i < n; ++i)
{
EXPECT_DOUBLE_EQ(v[i], 4.5);
}
oskar_mem_free(mem, &status);
}
void oskar_binary_read_mem_ext(oskar_Binary* handle, oskar_Mem* mem,
const char* name_group, const char* name_tag, int user_index,
int* status)
{
int type;
oskar_Mem *temp = 0, *data = 0;
size_t size_bytes = 0, element_size = 0;
/* Check if safe to proceed. */
if (*status) return;
/* Get the data type. */
type = oskar_mem_type(mem);
/* Initialise temporary (to zero length). */
temp = oskar_mem_create(type, OSKAR_CPU, 0, status);
/* Check if data is in CPU or GPU memory. */
data = (oskar_mem_location(mem) == OSKAR_CPU) ? mem : temp;
/* Query the tag index to find out how big the block is. */
element_size = oskar_mem_element_size(type);
oskar_binary_query_ext(handle, (unsigned char)type,
name_group, name_tag, user_index, &size_bytes, status);
/* Resize memory block if necessary, so that it can hold the data. */
oskar_mem_realloc(data, size_bytes / element_size, status);
/* Load the memory. */
oskar_binary_read_ext(handle, (unsigned char)type, name_group, name_tag,
user_index, size_bytes, oskar_mem_void(data), status);
/* Copy to GPU memory if required. */
if (oskar_mem_location(mem) != OSKAR_CPU)
oskar_mem_copy(mem, temp, status);
/* Free the temporary. */
oskar_mem_free(temp, status);
}
void oskar_telescope_set_noise_rms(oskar_Telescope* model,
double start, double end, int* status)
{
int i, j, num_channels;
double inc;
oskar_Station* s;
oskar_Mem *noise_rms_jy, *h;
/* Set noise RMS for all top-level stations. */
if (*status) return;
for (i = 0; i < model->num_stations; ++i)
{
s = model->station[i];
h = oskar_station_noise_rms_jy(s);
num_channels = (int)oskar_mem_length(oskar_station_noise_freq_hz(s));
if (num_channels == 0)
{
*status = OSKAR_ERR_OUT_OF_RANGE;
return;
}
oskar_mem_realloc(h, num_channels, status);
noise_rms_jy = oskar_mem_create(model->precision, OSKAR_CPU,
num_channels, status);
inc = (end - start) / (double)num_channels;
if (model->precision == OSKAR_DOUBLE)
{
double* r = oskar_mem_double(noise_rms_jy, status);
for (j = 0; j < num_channels; ++j) r[j] = start + j * inc;
}
else
{
float* r = oskar_mem_float(noise_rms_jy, status);
for (j = 0; j < num_channels; ++j) r[j] = start + j * inc;
}
oskar_mem_copy(h, noise_rms_jy, status);
oskar_mem_free(noise_rms_jy, status);
}
}
static void sim_baselines(oskar_Simulator* h, DeviceData* d, oskar_Sky* sky,
int channel_index_block, int time_index_block,
int time_index_simulation, int* status)
{
int num_baselines, num_stations, num_src, num_times_block, num_channels;
double dt_dump_days, t_start, t_dump, gast, frequency, ra0, dec0;
const oskar_Mem *x, *y, *z;
oskar_Mem* alias = 0;
/* Get dimensions. */
num_baselines = oskar_telescope_num_baselines(d->tel);
num_stations = oskar_telescope_num_stations(d->tel);
num_src = oskar_sky_num_sources(sky);
num_times_block = oskar_vis_block_num_times(d->vis_block);
num_channels = oskar_vis_block_num_channels(d->vis_block);
/* Return if there are no sources in the chunk,
* or if block time index requested is outside the valid range. */
if (num_src == 0 || time_index_block >= num_times_block) return;
/* Get the time and frequency of the visibility slice being simulated. */
dt_dump_days = h->time_inc_sec / 86400.0;
t_start = h->time_start_mjd_utc;
t_dump = t_start + dt_dump_days * (time_index_simulation + 0.5);
gast = oskar_convert_mjd_to_gast_fast(t_dump);
frequency = h->freq_start_hz + channel_index_block * h->freq_inc_hz;
/* Scale source fluxes with spectral index and rotation measure. */
oskar_sky_scale_flux_with_frequency(sky, frequency, status);
/* Evaluate station u,v,w coordinates. */
ra0 = oskar_telescope_phase_centre_ra_rad(d->tel);
dec0 = oskar_telescope_phase_centre_dec_rad(d->tel);
x = oskar_telescope_station_true_x_offset_ecef_metres_const(d->tel);
y = oskar_telescope_station_true_y_offset_ecef_metres_const(d->tel);
z = oskar_telescope_station_true_z_offset_ecef_metres_const(d->tel);
oskar_convert_ecef_to_station_uvw(num_stations, x, y, z, ra0, dec0, gast,
d->u, d->v, d->w, status);
/* Set dimensions of Jones matrices. */
if (d->R)
oskar_jones_set_size(d->R, num_stations, num_src, status);
if (d->Z)
oskar_jones_set_size(d->Z, num_stations, num_src, status);
oskar_jones_set_size(d->J, num_stations, num_src, status);
oskar_jones_set_size(d->E, num_stations, num_src, status);
oskar_jones_set_size(d->K, num_stations, num_src, status);
/* Evaluate station beam (Jones E: may be matrix). */
oskar_timer_resume(d->tmr_E);
oskar_evaluate_jones_E(d->E, num_src, OSKAR_RELATIVE_DIRECTIONS,
oskar_sky_l(sky), oskar_sky_m(sky), oskar_sky_n(sky), d->tel,
gast, frequency, d->station_work, time_index_simulation, status);
oskar_timer_pause(d->tmr_E);
#if 0
/* Evaluate ionospheric phase (Jones Z: scalar) and join with Jones E.
* NOTE this is currently only a CPU implementation. */
if (d->Z)
{
oskar_evaluate_jones_Z(d->Z, num_src, sky, d->tel,
&settings->ionosphere, gast, frequency, &(d->workJonesZ),
status);
oskar_timer_resume(d->tmr_join);
oskar_jones_join(d->E, d->Z, d->E, status);
oskar_timer_pause(d->tmr_join);
}
#endif
/* Evaluate parallactic angle (Jones R: matrix), and join with Jones Z*E.
* TODO Move this into station beam evaluation instead. */
if (d->R)
{
oskar_timer_resume(d->tmr_E);
oskar_evaluate_jones_R(d->R, num_src, oskar_sky_ra_rad_const(sky),
oskar_sky_dec_rad_const(sky), d->tel, gast, status);
oskar_timer_pause(d->tmr_E);
oskar_timer_resume(d->tmr_join);
oskar_jones_join(d->R, d->E, d->R, status);
oskar_timer_pause(d->tmr_join);
}
/* Evaluate interferometer phase (Jones K: scalar). */
oskar_timer_resume(d->tmr_K);
oskar_evaluate_jones_K(d->K, num_src, oskar_sky_l_const(sky),
oskar_sky_m_const(sky), oskar_sky_n_const(sky), d->u, d->v, d->w,
frequency, oskar_sky_I_const(sky),
h->source_min_jy, h->source_max_jy, status);
oskar_timer_pause(d->tmr_K);
/* Join Jones K with Jones Z*E. */
oskar_timer_resume(d->tmr_join);
oskar_jones_join(d->J, d->K, d->R ? d->R : d->E, status);
oskar_timer_pause(d->tmr_join);
/* Create alias for auto/cross-correlations. */
oskar_timer_resume(d->tmr_correlate);
alias = oskar_mem_create_alias(0, 0, 0, status);
/* Auto-correlate for this time and channel. */
if (oskar_vis_block_has_auto_correlations(d->vis_block))
{
oskar_mem_set_alias(alias,
oskar_vis_block_auto_correlations(d->vis_block),
num_stations *
(num_channels * time_index_block + channel_index_block),
num_stations, status);
oskar_auto_correlate(alias, num_src, d->J, sky, status);
}
/* Cross-correlate for this time and channel. */
if (oskar_vis_block_has_cross_correlations(d->vis_block))
{
oskar_mem_set_alias(alias,
oskar_vis_block_cross_correlations(d->vis_block),
num_baselines *
(num_channels * time_index_block + channel_index_block),
num_baselines, status);
oskar_cross_correlate(alias, num_src, d->J, sky, d->tel,
d->u, d->v, d->w, gast, frequency, status);
}
/* Free alias for auto/cross-correlations. */
oskar_mem_free(alias, status);
oskar_timer_pause(d->tmr_correlate);
}
static void set_up_vis_header(oskar_Simulator* h, int* status)
{
int num_stations, vis_type;
const double rad2deg = 180.0/M_PI;
int write_autocorr = 0, write_crosscorr = 0;
if (*status) return;
/* Check type of correlations to produce. */
if (h->correlation_type == 'C')
write_crosscorr = 1;
else if (h->correlation_type == 'A')
write_autocorr = 1;
else if (h->correlation_type == 'B')
{
write_autocorr = 1;
write_crosscorr = 1;
}
/* Create visibility header. */
num_stations = oskar_telescope_num_stations(h->tel);
vis_type = h->prec | OSKAR_COMPLEX;
if (oskar_telescope_pol_mode(h->tel) == OSKAR_POL_MODE_FULL)
vis_type |= OSKAR_MATRIX;
h->header = oskar_vis_header_create(vis_type, h->prec,
h->max_times_per_block, h->num_time_steps, h->num_channels,
h->num_channels, num_stations, write_autocorr, write_crosscorr,
status);
/* Add metadata from settings. */
oskar_vis_header_set_freq_start_hz(h->header, h->freq_start_hz);
oskar_vis_header_set_freq_inc_hz(h->header, h->freq_inc_hz);
oskar_vis_header_set_time_start_mjd_utc(h->header, h->time_start_mjd_utc);
oskar_vis_header_set_time_inc_sec(h->header, h->time_inc_sec);
/* Add settings file contents if defined. */
if (h->settings_path)
{
oskar_Mem* temp;
temp = oskar_mem_read_binary_raw(h->settings_path,
OSKAR_CHAR, OSKAR_CPU, status);
oskar_mem_copy(oskar_vis_header_settings(h->header), temp, status);
oskar_mem_free(temp, status);
}
/* Copy other metadata from telescope model. */
oskar_vis_header_set_time_average_sec(h->header,
oskar_telescope_time_average_sec(h->tel));
oskar_vis_header_set_channel_bandwidth_hz(h->header,
oskar_telescope_channel_bandwidth_hz(h->tel));
oskar_vis_header_set_phase_centre(h->header, 0,
oskar_telescope_phase_centre_ra_rad(h->tel) * rad2deg,
oskar_telescope_phase_centre_dec_rad(h->tel) * rad2deg);
oskar_vis_header_set_telescope_centre(h->header,
oskar_telescope_lon_rad(h->tel) * rad2deg,
oskar_telescope_lat_rad(h->tel) * rad2deg,
oskar_telescope_alt_metres(h->tel));
oskar_mem_copy(oskar_vis_header_station_x_offset_ecef_metres(h->header),
oskar_telescope_station_true_x_offset_ecef_metres_const(h->tel),
status);
oskar_mem_copy(oskar_vis_header_station_y_offset_ecef_metres(h->header),
oskar_telescope_station_true_y_offset_ecef_metres_const(h->tel),
status);
oskar_mem_copy(oskar_vis_header_station_z_offset_ecef_metres(h->header),
oskar_telescope_station_true_z_offset_ecef_metres_const(h->tel),
status);
}
void oskar_mem_evaluate_relative_error(const oskar_Mem* val_approx,
const oskar_Mem* val_accurate, double* min_rel_error,
double* max_rel_error, double* avg_rel_error, double* std_rel_error,
int* status)
{
int prec_approx, prec_accurate;
size_t i, n;
const oskar_Mem *app_ptr, *acc_ptr;
oskar_Mem *approx_temp = 0, *accurate_temp = 0;
double old_m = 0.0, new_m = 0.0, old_s = 0.0, new_s = 0.0;
/* Check if safe to proceed. */
if (*status) return;
/* Initialise outputs. */
if (max_rel_error) *max_rel_error = -DBL_MAX;
if (min_rel_error) *min_rel_error = DBL_MAX;
if (avg_rel_error) *avg_rel_error = DBL_MAX;
if (std_rel_error) *std_rel_error = DBL_MAX;
/* Type and dimension check. */
if (oskar_mem_is_matrix(val_approx) && !oskar_mem_is_matrix(val_accurate))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if (oskar_mem_is_complex(val_approx) && !oskar_mem_is_complex(val_accurate))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
/* Get and check base types. */
prec_approx = oskar_mem_precision(val_approx);
prec_accurate = oskar_mem_precision(val_accurate);
if (prec_approx != OSKAR_SINGLE && prec_approx != OSKAR_DOUBLE)
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
if (prec_accurate != OSKAR_SINGLE && prec_accurate != OSKAR_DOUBLE)
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
/* Get number of elements to check. */
n = oskar_mem_length(val_approx) < oskar_mem_length(val_accurate) ?
oskar_mem_length(val_approx) : oskar_mem_length(val_accurate);
if (oskar_mem_is_matrix(val_approx)) n *= 4;
/* Copy input data to temporary CPU arrays if required. */
app_ptr = val_approx;
acc_ptr = val_accurate;
if (oskar_mem_location(val_approx) != OSKAR_CPU)
{
approx_temp = oskar_mem_create_copy(val_approx, OSKAR_CPU,
status);
if (*status)
{
oskar_mem_free(approx_temp, status);
return;
}
app_ptr = approx_temp;
}
if (oskar_mem_location(val_accurate) != OSKAR_CPU)
{
accurate_temp = oskar_mem_create_copy(val_accurate, OSKAR_CPU,
status);
if (*status)
{
oskar_mem_free(accurate_temp, status);
return;
}
acc_ptr = accurate_temp;
}
/* Check numbers are the same, to appropriate precision. */
if (prec_approx == OSKAR_SINGLE && prec_accurate == OSKAR_SINGLE)
{
const float *approx, *accurate;
approx = oskar_mem_float_const(app_ptr, status);
accurate = oskar_mem_float_const(acc_ptr, status);
CHECK_ELEMENTS(1e-5)
}
else if (prec_approx == OSKAR_DOUBLE && prec_accurate == OSKAR_SINGLE)
