oskar_Sky* oskar_sky_read(const char* filename, int location, int* status)
{
int type = 0, num_sources = 0, idx = 0;
oskar_Binary* h = 0;
unsigned char group = OSKAR_TAG_GROUP_SKY_MODEL;
oskar_Sky* sky = 0;
/* Check if safe to proceed. */
if (*status) return 0;
/* Create the handle. */
h = oskar_binary_create(filename, 'r', status);
/* Read the sky model data parameters. */
oskar_binary_read_int(h, group, OSKAR_SKY_TAG_NUM_SOURCES, idx,
&num_sources, status);
oskar_binary_read_int(h, group, OSKAR_SKY_TAG_DATA_TYPE, idx,
&type, status);
/* Check if safe to proceed.
* Status flag will be set if binary read failed. */
if (*status)
{
oskar_binary_free(h);
return 0;
}
/* Create the sky model structure. */
sky = oskar_sky_create(type, location, num_sources, status);
/* Read the arrays. */
oskar_binary_read_mem(h, oskar_sky_ra_rad(sky),
group, OSKAR_SKY_TAG_RA, idx, status);
oskar_binary_read_mem(h, oskar_sky_dec_rad(sky),
group, OSKAR_SKY_TAG_DEC, idx, status);
oskar_binary_read_mem(h, oskar_sky_I(sky),
group, OSKAR_SKY_TAG_STOKES_I, idx, status);
oskar_binary_read_mem(h, oskar_sky_Q(sky),
group, OSKAR_SKY_TAG_STOKES_Q, idx, status);
oskar_binary_read_mem(h, oskar_sky_U(sky),
group, OSKAR_SKY_TAG_STOKES_U, idx, status);
oskar_binary_read_mem(h, oskar_sky_V(sky),
group, OSKAR_SKY_TAG_STOKES_V, idx, status);
oskar_binary_read_mem(h, oskar_sky_reference_freq_hz(sky),
group, OSKAR_SKY_TAG_REF_FREQ, idx, status);
oskar_binary_read_mem(h, oskar_sky_spectral_index(sky),
group, OSKAR_SKY_TAG_SPECTRAL_INDEX, idx, status);
oskar_binary_read_mem(h, oskar_sky_fwhm_major_rad(sky),
group, OSKAR_SKY_TAG_FWHM_MAJOR, idx, status);
oskar_binary_read_mem(h, oskar_sky_fwhm_minor_rad(sky),
group, OSKAR_SKY_TAG_FWHM_MINOR, idx, status);
oskar_binary_read_mem(h, oskar_sky_position_angle_rad(sky),
group, OSKAR_SKY_TAG_POSITION_ANGLE, idx, status);
oskar_binary_read_mem(h, oskar_sky_rotation_measure_rad(sky),
group, OSKAR_SKY_TAG_ROTATION_MEASURE, idx, status);
/* Release the handle. */
oskar_binary_free(h);
/* Return a handle to the sky model, or NULL if an error occurred. */
if (*status)
{
oskar_sky_free(sky, status);
sky = 0;
}
return sky;
}
TEST(binary_file, binary_read_write_mem)
{
const char filename[] = "temp_test_mem_binary.dat";
int num_cpu = 1000;
int num_gpu = 2048;
int status = 0;
// Create the handle.
oskar_Binary* h = oskar_binary_create(filename, 'w', &status);
// Save data from CPU.
{
oskar_Mem* mem = oskar_mem_create(OSKAR_SINGLE, OSKAR_CPU,
num_cpu, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
float* data = oskar_mem_float(mem, &status);
// Fill array with data.
for (int i = 0; i < num_cpu; ++i)
{
data[i] = i * 1024.0;
}
// Save CPU data.
oskar_binary_write_mem_ext(h, mem, "USER", "TEST", 987654, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_mem_free(mem, &status);
}
// Save data from GPU.
{
oskar_Mem *mem_cpu, *mem_gpu;
mem_cpu = oskar_mem_create(OSKAR_DOUBLE_COMPLEX, OSKAR_CPU,
num_gpu, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
double2* data = oskar_mem_double2(mem_cpu, &status);
// Fill array with data.
for (int i = 0; i < num_gpu; ++i)
{
data[i].x = i * 10.0;
data[i].y = i * 20.0 + 1.0;
}
// Copy data to GPU.
mem_gpu = oskar_mem_create_copy(mem_cpu, OSKAR_GPU, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Save GPU data.
oskar_binary_write_mem_ext(h, mem_gpu, "AA", "BB", 2, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_mem_free(mem_cpu, &status);
oskar_mem_free(mem_gpu, &status);
}
// Save a single integer with a large index.
int val = 0xFFFFFF;
oskar_binary_write_int(h, 50, 9, 800000, val, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Save data from CPU with blank tags.
{
oskar_Mem* mem = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_cpu, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
double* data = oskar_mem_double(mem, &status);
// Fill array with data.
for (int i = 0; i < num_cpu; ++i)
{
data[i] = i * 500.0;
}
// Save CPU data.
oskar_binary_write_mem_ext(h, mem, "", "", 10, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Fill array with data.
for (int i = 0; i < num_cpu; ++i)
{
data[i] = i * 501.0;
}
// Save CPU data.
oskar_binary_write_mem_ext(h, mem, "", "", 11, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_mem_free(mem, &status);
}
// Save CPU data with tags that are equal lengths.
{
oskar_Mem* mem = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_cpu, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
double* data = oskar_mem_double(mem, &status);
// Fill array with data.
for (int i = 0; i < num_cpu; ++i)
{
data[i] = i * 1001.0;
}
// Save CPU data.
oskar_binary_write_mem_ext(h, mem, "DOG", "CAT", 0, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Fill array with data.
for (int i = 0; i < num_cpu; ++i)
{
data[i] = i * 127.0;
}
// Save CPU data.
oskar_binary_write_mem_ext(h, mem, "ONE", "TWO", 0, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_mem_free(mem, &status);
}
// Create the handle for reading.
oskar_binary_free(h);
h = oskar_binary_create(filename, 'r', &status);
// Load data directly to GPU.
{
oskar_Mem *mem_gpu, *mem_cpu;
mem_gpu = oskar_mem_create(OSKAR_DOUBLE_COMPLEX, OSKAR_GPU,
0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_binary_read_mem_ext(h, mem_gpu, "AA", "BB", 2, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
EXPECT_EQ(num_gpu, (int)oskar_mem_length(mem_gpu));
// Copy back to CPU and examine contents.
mem_cpu = oskar_mem_create_copy(mem_gpu, OSKAR_CPU, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
double2* data = oskar_mem_double2(mem_cpu, &status);
for (int i = 0; i < num_gpu; ++i)
{
EXPECT_DOUBLE_EQ(i * 10.0, data[i].x);
EXPECT_DOUBLE_EQ(i * 20.0 + 1.0, data[i].y);
}
oskar_mem_free(mem_cpu, &status);
oskar_mem_free(mem_gpu, &status);
}
// Load integer with a large index.
int new_val = 0;
oskar_binary_read_int(h, 50, 9, 800000, &new_val, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
EXPECT_EQ(val, new_val);
// Load CPU data.
{
oskar_Mem* mem = oskar_mem_create(OSKAR_SINGLE, OSKAR_CPU,
num_cpu, &status);
oskar_binary_read_mem_ext(h, mem, "USER", "TEST", 987654, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
ASSERT_EQ(num_cpu, (int)oskar_mem_length(mem));
float* data = oskar_mem_float(mem, &status);
for (int i = 0; i < num_cpu; ++i)
{
EXPECT_DOUBLE_EQ(i * 1024.0, data[i]);
}
oskar_mem_free(mem, &status);
}
// Load CPU data with blank tags.
{
double* data;
oskar_Mem* mem = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_cpu, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_binary_read_mem_ext(h, mem, "", "", 10, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_binary_read_mem_ext(h, mem, "DOESN'T", "EXIST", 10, &status);
EXPECT_EQ((int)OSKAR_ERR_BINARY_TAG_NOT_FOUND, status);
status = 0;
ASSERT_EQ(num_cpu, (int)oskar_mem_length(mem));
data = oskar_mem_double(mem, &status);
for (int i = 0; i < num_cpu; ++i)
{
EXPECT_DOUBLE_EQ(i * 500.0, data[i]);
}
oskar_binary_read_mem_ext(h, mem, "", "", 11, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
ASSERT_EQ(num_cpu, (int)oskar_mem_length(mem));
data = oskar_mem_double(mem, &status);
for (int i = 0; i < num_cpu; ++i)
{
EXPECT_DOUBLE_EQ(i * 501.0, data[i]);
}
oskar_mem_free(mem, &status);
}
// Load CPU data with tags that are equal lengths.
{
double* data;
oskar_Mem* mem = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0,
&status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_binary_read_mem_ext(h, mem, "ONE", "TWO", 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
ASSERT_EQ(num_cpu, (int)oskar_mem_length(mem));
data = oskar_mem_double(mem, &status);
for (int i = 0; i < num_cpu; ++i)
{
EXPECT_DOUBLE_EQ(i * 127.0, data[i]);
}
oskar_binary_read_mem_ext(h, mem, "DOG", "CAT", 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
ASSERT_EQ(num_cpu, (int)oskar_mem_length(mem));
data = oskar_mem_double(mem, &status);
for (int i = 0; i < num_cpu; ++i)
{
EXPECT_DOUBLE_EQ(i * 1001.0, data[i]);
}
oskar_mem_free(mem, &status);
}
// Try to load data that isn't present.
{
oskar_Mem* mem = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0,
&status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_binary_read_mem_ext(h, mem, "DOESN'T", "EXIST", 10, &status);
EXPECT_EQ((int)OSKAR_ERR_BINARY_TAG_NOT_FOUND, status);
status = 0;
EXPECT_EQ(0, (int)oskar_mem_length(mem));
oskar_mem_free(mem, &status);
}
// Release the handle.
oskar_binary_free(h);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
}
oskar_Vis* oskar_vis_read(oskar_Binary* h, int* status)
{
/* Visibility metadata. */
int num_channels = 0, num_times = 0, num_stations = 0, tag_error = 0;
int amp_type = 0;
unsigned char grp = OSKAR_TAG_GROUP_VISIBILITY;
oskar_Vis* vis = 0;
/* Check if safe to proceed. */
if (*status) return 0;
/* Read visibility dimensions. */
oskar_binary_read_int(h, grp, OSKAR_VIS_TAG_NUM_CHANNELS, 0,
&num_channels, status);
if (*status == OSKAR_ERR_BINARY_TAG_NOT_FOUND)
{
/* Try to read a new format visibility file. */
*status = 0;
return oskar_vis_read_new(h, status);
}
else if (*status) return 0;
oskar_binary_read_int(h, grp, OSKAR_VIS_TAG_NUM_TIMES, 0,
&num_times, status);
oskar_binary_read_int(h, grp, OSKAR_VIS_TAG_NUM_STATIONS, 0,
&num_stations, &tag_error);
if (tag_error == OSKAR_ERR_BINARY_TAG_NOT_FOUND)
{
/* Check for number of baselines if number of stations not present. */
int num_baselines = 0;
oskar_binary_read_int(h, grp, OSKAR_VIS_TAG_NUM_BASELINES, 0,
&num_baselines, status);
/* Convert baselines to stations (care using floating point here). */
num_stations = (int) floor(0.5 +
(1.0 + sqrt(1.0 + 8.0 * num_baselines)) / 2.0);
}
else if (tag_error) *status = tag_error;
oskar_binary_read_int(h, grp, OSKAR_VIS_TAG_AMP_TYPE, 0, &_type, status);
/* Check if safe to proceed. */
if (*status) return 0;
/* Create the visibility structure. */
vis = oskar_vis_create(amp_type, OSKAR_CPU, num_channels, num_times,
num_stations, status);
/* Optionally read the settings path (ignore the error code). */
tag_error = 0;
oskar_binary_read_mem(h, vis->settings_path,
OSKAR_TAG_GROUP_SETTINGS, OSKAR_TAG_SETTINGS_PATH, 0, &tag_error);
/* Optionally read the settings data (ignore the error code). */
tag_error = 0;
oskar_binary_read_mem(h, vis->settings,
OSKAR_TAG_GROUP_SETTINGS, OSKAR_TAG_SETTINGS, 0, &tag_error);
/* Optionally read the telescope model path (ignore the error code). */
tag_error = 0;
oskar_binary_read_mem(h, vis->telescope_path,
grp, OSKAR_VIS_TAG_TELESCOPE_PATH, 0, &tag_error);
/* Read visibility metadata. */
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_FREQ_START_HZ, 0,
&vis->freq_start_hz, status);
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_FREQ_INC_HZ, 0,
&vis->freq_inc_hz, status);
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_TIME_START_MJD_UTC, 0,
&vis->time_start_mjd_utc, status);
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_TIME_INC_SEC, 0,
&vis->time_inc_sec, status);
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_PHASE_CENTRE_RA, 0,
&vis->phase_centre_ra_deg, status);
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_PHASE_CENTRE_DEC, 0,
&vis->phase_centre_dec_deg, status);
/* Read the baseline coordinate arrays. */
oskar_binary_read_mem(h, vis->baseline_uu_metres, grp,
OSKAR_VIS_TAG_BASELINE_UU, 0, status);
oskar_binary_read_mem(h, vis->baseline_vv_metres, grp,
OSKAR_VIS_TAG_BASELINE_VV, 0, status);
oskar_binary_read_mem(h, vis->baseline_ww_metres, grp,
OSKAR_VIS_TAG_BASELINE_WW, 0, status);
/* Read the visibility data. */
oskar_binary_read_mem(h, vis->amplitude, grp,
OSKAR_VIS_TAG_AMPLITUDE, 0, status);
/* Optionally read station coordinates (ignore the error code). */
tag_error = 0;
oskar_binary_read_mem(h, vis->station_x_offset_ecef_metres,
grp, OSKAR_VIS_TAG_STATION_X_OFFSET_ECEF, 0, &tag_error);
oskar_binary_read_mem(h, vis->station_y_offset_ecef_metres,
grp, OSKAR_VIS_TAG_STATION_Y_OFFSET_ECEF, 0, &tag_error);
oskar_binary_read_mem(h, vis->station_z_offset_ecef_metres,
grp, OSKAR_VIS_TAG_STATION_Z_OFFSET_ECEF, 0, &tag_error);
/* Optionally read telescope lon., lat., alt. (ignore the error code) */
tag_error = 0;
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_TELESCOPE_LON, 0,
&vis->telescope_lon_deg, &tag_error);
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_TELESCOPE_LAT, 0,
&vis->telescope_lat_deg, &tag_error);
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_TELESCOPE_ALT, 0,
&vis->telescope_alt_metres, &tag_error);
/* Optionally read the channel bandwidth value. */
tag_error = 0;
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_CHANNEL_BANDWIDTH_HZ, 0,
&vis->channel_bandwidth_hz, &tag_error);
/* Optionally read the time integration value. */
tag_error = 0;
oskar_binary_read_double(h, grp, OSKAR_VIS_TAG_TIME_AVERAGE_SEC, 0,
&vis->time_average_sec, &tag_error);
/* Return a handle to the new structure. */
return vis;
}
