int oskar_find_closest_match(double value, const oskar_Mem* values,
int* status)
{
int type, num_values, match_index = 0;
/* Check if safe to proceed. */
if (*status) return 0;
/* Check location. */
if (oskar_mem_location(values) != OSKAR_CPU)
{
*status = OSKAR_ERR_BAD_LOCATION;
return 0;
}
/* Switch on type. */
type = oskar_mem_type(values);
num_values = (int)oskar_mem_length(values);
if (type == OSKAR_DOUBLE)
{
match_index = oskar_find_closest_match_d(value, num_values,
oskar_mem_double_const(values, status));
}
else if (type == OSKAR_SINGLE)
{
match_index = oskar_find_closest_match_f(value, num_values,
oskar_mem_float_const(values, status));
}
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
return match_index;
}
static void evaluate_jones_Z_station(oskar_Mem* Z_station,
double wavelength, const oskar_Mem* TEC, const oskar_Mem* hor_z,
double min_elevation, int num_pp, int* status)
{
int i, type;
double arg;
/* Check if safe to proceed. */
if (*status) return;
type = oskar_mem_type(Z_station);
if (type == OSKAR_DOUBLE_COMPLEX)
{
double2* Z = oskar_mem_double2(Z_station, status);
for (i = 0; i < num_pp; ++i)
{
/* Initialise as an unit scalar Z = (1 + 0i) i.e. no phase change */
Z[i].x = 1.0;
Z[i].y = 0.0;
/* If the pierce point is below the minimum specified elevation
* don't evaluate a phase */
if (asin((oskar_mem_double_const(hor_z, status))[i]) <
min_elevation)
continue;
arg = wavelength * 25. * oskar_mem_double_const(TEC, status)[i];
/* Z phase == exp(i * lambda * 25 * tec) */
Z[i].x = cos(arg);
Z[i].y = sin(arg);
}
}
else if (type == OSKAR_SINGLE_COMPLEX)
{
float2* Z = oskar_mem_float2(Z_station, status);
for (i = 0; i < num_pp; ++i)
{
/* Initialise as an unit scalar Z = (1 + 0i) i.e. no phase change */
Z[i].x = 1.0;
Z[i].y = 0.0;
/* If the pierce point is below the minimum specified elevation
* don't evaluate a phase */
if (asin((oskar_mem_float_const(hor_z, status))[i]) <
min_elevation)
continue;
arg = wavelength * 25. * oskar_mem_float_const(TEC, status)[i];
/* Z phase == exp(i * lambda * 25 * tec) */
Z[i].x = cos(arg);
Z[i].y = sin(arg);
}
}
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
}
void oskar_convert_station_uvw_to_baseline_uvw(int num_stations, int offset_in,
const oskar_Mem* u, const oskar_Mem* v, const oskar_Mem* w,
int offset_out, oskar_Mem* uu, oskar_Mem* vv, oskar_Mem* ww,
int* status)
{
if (*status) return;
const int type = oskar_mem_type(u);
const int location = oskar_mem_location(u);
if (location == OSKAR_CPU)
{
if (type == OSKAR_SINGLE)
convert_station_uvw_to_baseline_uvw_float(num_stations, offset_in,
oskar_mem_float_const(u, status),
oskar_mem_float_const(v, status),
oskar_mem_float_const(w, status), offset_out,
oskar_mem_float(uu, status),
oskar_mem_float(vv, status),
oskar_mem_float(ww, status));
else if (type == OSKAR_DOUBLE)
convert_station_uvw_to_baseline_uvw_double(num_stations, offset_in,
oskar_mem_double_const(u, status),
oskar_mem_double_const(v, status),
oskar_mem_double_const(w, status), offset_out,
oskar_mem_double(uu, status),
oskar_mem_double(vv, status),
oskar_mem_double(ww, status));
else
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
else
{
size_t local_size[] = {32, 1, 1}, global_size[] = {1, 1, 1};
const char* k = 0;
if (type == OSKAR_SINGLE)
k = "convert_station_uvw_to_baseline_uvw_float";
else if (type == OSKAR_DOUBLE)
k = "convert_station_uvw_to_baseline_uvw_double";
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
oskar_device_check_local_size(location, 0, local_size);
global_size[0] = num_stations * local_size[0];
const oskar_Arg args[] = {
{INT_SZ, &num_stations},
{INT_SZ, &offset_in},
{PTR_SZ, oskar_mem_buffer_const(u)},
{PTR_SZ, oskar_mem_buffer_const(v)},
{PTR_SZ, oskar_mem_buffer_const(w)},
{INT_SZ, &offset_out},
{PTR_SZ, oskar_mem_buffer(uu)},
{PTR_SZ, oskar_mem_buffer(vv)},
{PTR_SZ, oskar_mem_buffer(ww)}
};
oskar_device_launch_kernel(k, location, 1, local_size, global_size,
sizeof(args) / sizeof(oskar_Arg), args, 0, 0, status);
}
}
oskar_Mem* oskar_mem_create_copy(const oskar_Mem* src, int location,
int* status)
{
oskar_Mem* mem = 0;
/* Check if safe to proceed. */
if (*status) return 0;
/* Create the new structure. */
mem = oskar_mem_create(oskar_mem_type(src), location,
oskar_mem_length(src), status);
if (!mem || *status)
return mem;
/* Copy the memory. */
oskar_mem_copy_contents(mem, src, 0, 0, oskar_mem_length(src), status);
/* Return a handle to the new structure. */
return mem;
}
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);
}
static void evaluate_station_ECEF_coords(
double* station_x, double* station_y, double* station_z,
int stationID, const oskar_Telescope* telescope)
{
double st_x, st_y, st_z;
double lon, lat, alt;
const oskar_Station* station;
const void *x_, *y_, *z_;
x_ = oskar_mem_void_const(
oskar_telescope_station_true_x_offset_ecef_metres_const(telescope));
y_ = oskar_mem_void_const(
oskar_telescope_station_true_y_offset_ecef_metres_const(telescope));
z_ = oskar_mem_void_const(
oskar_telescope_station_true_z_offset_ecef_metres_const(telescope));
station = oskar_telescope_station_const(telescope, stationID);
lon = oskar_station_lon_rad(station);
lat = oskar_station_lat_rad(station);
alt = oskar_station_alt_metres(station);
if (oskar_mem_type(
oskar_telescope_station_true_x_offset_ecef_metres_const(telescope)) ==
OSKAR_DOUBLE)
{
st_x = ((const double*)x_)[stationID];
st_y = ((const double*)y_)[stationID];
st_z = ((const double*)z_)[stationID];
}
else
{
st_x = (double)((const float*)x_)[stationID];
st_y = (double)((const float*)y_)[stationID];
st_z = (double)((const float*)z_)[stationID];
}
oskar_convert_offset_ecef_to_ecef(1, &st_x, &st_y, &st_z, lon, lat, alt,
station_x, station_y, station_z);
}
void oskar_mem_save_ascii(FILE* file, size_t num_mem,
size_t offset, size_t num_elements, int* status, ...)
{
int type;
size_t i, j;
va_list args;
oskar_Mem** handles; /* Array of oskar_Mem pointers in CPU memory. */
/* Check if safe to proceed. */
if (*status) return;
/* Check there are at least the number of specified elements in
* each array. */
va_start(args, status);
for (i = 0; i < num_mem; ++i)
{
const oskar_Mem* mem;
mem = va_arg(args, const oskar_Mem*);
if (oskar_mem_length(mem) < num_elements)
*status = OSKAR_ERR_DIMENSION_MISMATCH;
}
va_end(args);
/* Check if safe to proceed. */
if (*status) return;
/* Allocate and set up the handle array. */
handles = (oskar_Mem**) malloc(num_mem * sizeof(oskar_Mem*));
va_start(args, status);
for (i = 0; i < num_mem; ++i)
{
oskar_Mem* mem;
mem = va_arg(args, oskar_Mem*);
if (oskar_mem_location(mem) != OSKAR_CPU)
{
handles[i] = oskar_mem_create_copy(mem, OSKAR_CPU, status);
}
else
{
handles[i] = mem;
}
}
va_end(args);
for (j = 0; j < num_elements; ++j)
{
/* Break if error. */
if (*status) break;
for (i = 0; i < num_mem; ++i)
{
const void* data;
data = oskar_mem_void_const(handles[i]);
type = oskar_mem_type(handles[i]);
switch (type)
{
case OSKAR_SINGLE:
{
fprintf(file, SDF, ((const float*)data)[j + offset]);
continue;
}
case OSKAR_DOUBLE:
{
fprintf(file, SDD, ((const double*)data)[j + offset]);
continue;
}
case OSKAR_SINGLE_COMPLEX:
{
float2 d;
d = ((const float2*)data)[j + offset];
fprintf(file, SDF SDF, d.x, d.y);
continue;
}
case OSKAR_DOUBLE_COMPLEX:
{
double2 d;
d = ((const double2*)data)[j + offset];
fprintf(file, SDD SDD, d.x, d.y);
continue;
}
case OSKAR_SINGLE_COMPLEX_MATRIX:
{
float4c d;
d = ((const float4c*)data)[j + offset];
fprintf(file, SDF SDF SDF SDF SDF SDF SDF SDF,
d.a.x, d.a.y, d.b.x, d.b.y, d.c.x, d.c.y, d.d.x, d.d.y);
continue;
}
case OSKAR_DOUBLE_COMPLEX_MATRIX:
{
double4c d;
d = ((const double4c*)data)[j + offset];
fprintf(file, SDD SDD SDD SDD SDD SDD SDD SDD,
d.a.x, d.a.y, d.b.x, d.b.y, d.c.x, d.c.y, d.d.x, d.d.y);
continue;
}
case OSKAR_CHAR:
{
putc(((const char*)data)[j + offset], file);
continue;
}
case OSKAR_INT:
{
fprintf(file, "%5d ", ((const int*)data)[j + offset]);
continue;
}
default:
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
continue;
}
}
}
putc('\n', file);
}
/* Free any temporary memory used by this function. */
va_start(args, status);
for (i = 0; i < num_mem; ++i)
{
const oskar_Mem* mem;
mem = va_arg(args, const oskar_Mem*);
if (oskar_mem_location(mem) != OSKAR_CPU)
{
oskar_mem_free(handles[i], status);
}
}
va_end(args);
/* Free the handle array. */
free(handles);
}
void oskar_evaluate_element_weights_dft(int num_elements,
const oskar_Mem* x, const oskar_Mem* y, const oskar_Mem* z,
double wavenumber, double x_beam, double y_beam, double z_beam,
oskar_Mem* weights, int* status)
{
if (*status) return;
const int location = oskar_mem_location(weights);
const int type = oskar_mem_type(weights);
const int precision = oskar_mem_precision(weights);
if (oskar_mem_location(x) != location ||
oskar_mem_location(y) != location ||
oskar_mem_location(z) != location)
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
if (oskar_mem_type(x) != precision || oskar_mem_type(y) != precision ||
oskar_mem_type(z) != precision)
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if ((int)oskar_mem_length(weights) < num_elements ||
(int)oskar_mem_length(x) < num_elements ||
(int)oskar_mem_length(y) < num_elements ||
(int)oskar_mem_length(z) < num_elements)
{
*status = OSKAR_ERR_DIMENSION_MISMATCH;
return;
}
if (location == OSKAR_CPU)
{
if (type == OSKAR_DOUBLE_COMPLEX)
evaluate_element_weights_dft_d(num_elements,
oskar_mem_double_const(x, status),
oskar_mem_double_const(y, status),
oskar_mem_double_const(z, status),
wavenumber, x_beam, y_beam, z_beam,
oskar_mem_double2(weights, status));
else if (type == OSKAR_SINGLE_COMPLEX)
evaluate_element_weights_dft_f(num_elements,
oskar_mem_float_const(x, status),
oskar_mem_float_const(y, status),
oskar_mem_float_const(z, status),
wavenumber, x_beam, y_beam, z_beam,
oskar_mem_float2(weights, status));
else
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
else
{
size_t local_size[] = {256, 1, 1}, global_size[] = {1, 1, 1};
const char* k = 0;
const int is_dbl = oskar_mem_is_double(weights);
if (type == OSKAR_DOUBLE_COMPLEX)
k = "evaluate_element_weights_dft_double";
else if (type == OSKAR_SINGLE_COMPLEX)
k = "evaluate_element_weights_dft_float";
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
const float w = (float) wavenumber;
const float x1 = (float) x_beam;
const float y1 = (float) y_beam;
const float z1 = (float) z_beam;
oskar_device_check_local_size(location, 0, local_size);
global_size[0] = oskar_device_global_size(
(size_t) num_elements, local_size[0]);
const oskar_Arg args[] = {
{INT_SZ, &num_elements},
{PTR_SZ, oskar_mem_buffer_const(x)},
{PTR_SZ, oskar_mem_buffer_const(y)},
{PTR_SZ, oskar_mem_buffer_const(z)},
{is_dbl ? DBL_SZ : FLT_SZ,
is_dbl ? (const void*)&wavenumber : (const void*)&w},
{is_dbl ? DBL_SZ : FLT_SZ,
is_dbl ? (const void*)&x_beam : (const void*)&x1},
{is_dbl ? DBL_SZ : FLT_SZ,
is_dbl ? (const void*)&y_beam : (const void*)&y1},
{is_dbl ? DBL_SZ : FLT_SZ,
is_dbl ? (const void*)&z_beam : (const void*)&z1},
{PTR_SZ, oskar_mem_buffer(weights)}
};
oskar_device_launch_kernel(k, location, 1, local_size, global_size,
sizeof(args) / sizeof(oskar_Arg), args, 0, 0, status);
}
}
void oskar_beam_pattern_generate_coordinates(oskar_BeamPattern* h,
int beam_coord_type, int* status)
{
size_t num_pixels = 0;
int nside = 0;
/* Check if safe to proceed. */
if (*status) return;
/* If memory is already allocated, do nothing. */
if (h->x) return;
/* Calculate number of pixels if possible. */
if (h->coord_grid_type == 'B') /* Beam image */
{
num_pixels = h->width * h->height;
}
else if (h->coord_grid_type == 'H') /* Healpix */
{
nside = h->nside;
num_pixels = 12 * nside * nside;
}
else if (h->coord_grid_type == 'S') /* Sky model */
num_pixels = 0;
else
{
*status = OSKAR_ERR_INVALID_ARGUMENT;
return;
}
/* Create output arrays. */
h->x = oskar_mem_create(h->prec, OSKAR_CPU, num_pixels, status);
h->y = oskar_mem_create(h->prec, OSKAR_CPU, num_pixels, status);
h->z = oskar_mem_create(h->prec, OSKAR_CPU, num_pixels, status);
/* Get equatorial or horizon coordinates. */
if (h->coord_frame_type == 'E')
{
/*
* Equatorial coordinates.
*/
switch (h->coord_grid_type)
{
case 'B': /* Beam image */
{
oskar_evaluate_image_lmn_grid(h->width, h->height,
h->fov_deg[0]*(M_PI/180.0), h->fov_deg[1]*(M_PI/180.0), 1,
h->x, h->y, h->z, status);
break;
}
case 'H': /* Healpix */
{
int num_points, type, i;
double ra0 = 0.0, dec0 = 0.0;
oskar_Mem *theta, *phi;
/* Generate theta and phi from nside. */
num_points = 12 * nside * nside;
type = oskar_mem_type(h->x);
theta = oskar_mem_create(type, OSKAR_CPU, num_points, status);
phi = oskar_mem_create(type, OSKAR_CPU, num_points, status);
oskar_convert_healpix_ring_to_theta_phi(nside, theta, phi, status);
/* Convert theta from polar angle to elevation. */
if (type == OSKAR_DOUBLE)
{
double* theta_ = oskar_mem_double(theta, status);
for (i = 0; i < num_points; ++i)
theta_[i] = 90.0 - theta_[i];
}
else if (type == OSKAR_SINGLE)
{
float* theta_ = oskar_mem_float(theta, status);
for (i = 0; i < num_points; ++i)
theta_[i] = 90.0f - theta_[i];
}
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
/* Evaluate beam phase centre coordinates in equatorial frame. */
if (beam_coord_type == OSKAR_SPHERICAL_TYPE_EQUATORIAL)
{
ra0 = oskar_telescope_phase_centre_ra_rad(h->tel);
dec0 = oskar_telescope_phase_centre_dec_rad(h->tel);
}
else if (beam_coord_type == OSKAR_SPHERICAL_TYPE_AZEL)
{
/* TODO convert from az0, el0 to ra0, dec0 */
*status = OSKAR_FAIL;
}
else
{
*status = OSKAR_ERR_INVALID_ARGUMENT;
}
/* Convert equatorial angles to direction cosines in the frame
* of the beam phase centre. */
oskar_convert_lon_lat_to_relative_directions(num_points,
phi, theta, ra0, dec0, h->x, h->y, h->z, status);
/* Free memory. */
oskar_mem_free(theta, status);
oskar_mem_free(phi, status);
break;
}
case 'S': /* Sky model */
{
oskar_Mem *ra, *dec;
int type = 0, num_points = 0;
type = oskar_mem_type(h->x);
ra = oskar_mem_create(type, OSKAR_CPU, 0, status);
dec = oskar_mem_create(type, OSKAR_CPU, 0, status);
load_coords(ra, dec, h->sky_model_file, status);
num_points = oskar_mem_length(ra);
oskar_mem_realloc(h->x, num_points, status);
oskar_mem_realloc(h->y, num_points, status);
oskar_mem_realloc(h->z, num_points, status);
oskar_convert_lon_lat_to_relative_directions(
num_points, ra, dec,
oskar_telescope_phase_centre_ra_rad(h->tel),
oskar_telescope_phase_centre_dec_rad(h->tel),
h->x, h->y, h->z, status);
oskar_mem_free(ra, status);
oskar_mem_free(dec, status);
break;
}
default:
*status = OSKAR_ERR_INVALID_ARGUMENT;
break;
};
/* Set the return values. */
h->coord_type = OSKAR_RELATIVE_DIRECTIONS;
h->lon0 = oskar_telescope_phase_centre_ra_rad(h->tel);
h->lat0 = oskar_telescope_phase_centre_dec_rad(h->tel);
}
else if (h->coord_frame_type == 'H')
{
/*
* Horizon coordinates.
*/
switch (h->coord_grid_type)
{
case 'B': /* Beam image */
{
/* NOTE: This is for an all-sky image centred on the zenith. */
oskar_evaluate_image_lmn_grid(h->width, h->height,
M_PI, M_PI, 1, h->x, h->y, h->z, status);
break;
}
case 'H': /* Healpix */
{
int num_points, type;
oskar_Mem *theta, *phi;
num_points = 12 * nside * nside;
type = oskar_mem_type(h->x);
theta = oskar_mem_create(type, OSKAR_CPU, num_points, status);
phi = oskar_mem_create(type, OSKAR_CPU, num_points, status);
oskar_convert_healpix_ring_to_theta_phi(nside, theta, phi, status);
oskar_convert_theta_phi_to_enu_directions(num_points,
theta, phi, h->x, h->y, h->z, status);
oskar_mem_free(theta, status);
oskar_mem_free(phi, status);
break;
}
default:
*status = OSKAR_ERR_INVALID_ARGUMENT;
break;
};
/* Set the return values. */
h->coord_type = OSKAR_ENU_DIRECTIONS;
h->lon0 = 0.0;
h->lat0 = M_PI / 2.0;
}
else
{
*status = OSKAR_ERR_INVALID_ARGUMENT;
}
/* Set the number of pixels. */
h->num_pixels = oskar_mem_length(h->x);
}
void oskar_convert_ludwig3_to_theta_phi_components(
int num_points, const oskar_Mem* phi, int stride, int offset,
oskar_Mem* vec, int* status)
{
if (*status) return;
const int type = oskar_mem_type(phi);
const int location = oskar_mem_location(phi);
const int off_h = offset, off_v = offset + 1;
if (!oskar_mem_is_matrix(vec))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if (location == OSKAR_CPU)
{
if (type == OSKAR_SINGLE)
convert_ludwig3_to_theta_phi_float(
num_points,
oskar_mem_float_const(phi, status),
stride, off_h, off_v,
oskar_mem_float2(vec, status),
oskar_mem_float2(vec, status));
else if (type == OSKAR_DOUBLE)
convert_ludwig3_to_theta_phi_double(
num_points,
oskar_mem_double_const(phi, status),
stride, off_h, off_v,
oskar_mem_double2(vec, status),
oskar_mem_double2(vec, status));
else
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
else
{
size_t local_size[] = {256, 1, 1}, global_size[] = {1, 1, 1};
const char* k = 0;
if (type == OSKAR_SINGLE)
k = "convert_ludwig3_to_theta_phi_float";
else if (type == OSKAR_DOUBLE)
k = "convert_ludwig3_to_theta_phi_double";
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
oskar_device_check_local_size(location, 0, local_size);
global_size[0] = oskar_device_global_size(
(size_t) num_points, local_size[0]);
const oskar_Arg args[] = {
{INT_SZ, &num_points},
{PTR_SZ, oskar_mem_buffer_const(phi)},
{INT_SZ, &stride},
{INT_SZ, &off_h},
{INT_SZ, &off_v},
{PTR_SZ, oskar_mem_buffer(vec)},
{PTR_SZ, oskar_mem_buffer(vec)}
};
oskar_device_launch_kernel(k, location, 1, local_size, global_size,
sizeof(args) / sizeof(oskar_Arg), args, 0, 0, status);
}
}
void oskar_dftw(
int normalise,
int num_in,
double wavenumber,
const oskar_Mem* weights_in,
const oskar_Mem* x_in,
const oskar_Mem* y_in,
const oskar_Mem* z_in,
int offset_coord_out,
int num_out,
const oskar_Mem* x_out,
const oskar_Mem* y_out,
const oskar_Mem* z_out,
const oskar_Mem* data,
int offset_out,
oskar_Mem* output,
int* status)
{
if (*status) return;
const int location = oskar_mem_location(output);
const int type = oskar_mem_precision(output);
const int is_dbl = oskar_mem_is_double(output);
const int is_3d = (z_in != NULL && z_out != NULL);
const int is_data = (data != NULL);
const int is_matrix = oskar_mem_is_matrix(output);
if (!oskar_mem_is_complex(output) || !oskar_mem_is_complex(weights_in) ||
oskar_mem_is_matrix(weights_in))
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
if (oskar_mem_location(weights_in) != location ||
oskar_mem_location(x_in) != location ||
oskar_mem_location(y_in) != location ||
oskar_mem_location(x_out) != location ||
oskar_mem_location(y_out) != location)
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
if (oskar_mem_precision(weights_in) != type ||
oskar_mem_type(x_in) != type ||
oskar_mem_type(y_in) != type ||
oskar_mem_type(x_out) != type ||
oskar_mem_type(y_out) != type)
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if (is_data)
{
if (oskar_mem_location(data) != location)
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
if (!oskar_mem_is_complex(data) ||
oskar_mem_type(data) != oskar_mem_type(output) ||
oskar_mem_precision(data) != type)
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
}
if (is_3d)
{
if (oskar_mem_location(z_in) != location ||
oskar_mem_location(z_out) != location)
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
if (oskar_mem_type(z_in) != type || oskar_mem_type(z_out) != type)
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
}
oskar_mem_ensure(output, (size_t) offset_out + num_out, status);
if (*status) return;
if (location == OSKAR_CPU)
{
if (is_data)
{
if (is_matrix)
{
if (is_3d)
{
if (is_dbl)
dftw_m2m_3d_double(num_in, wavenumber,
oskar_mem_double2_const(weights_in, status),
oskar_mem_double_const(x_in, status),
oskar_mem_double_const(y_in, status),
oskar_mem_double_const(z_in, status),
offset_coord_out, num_out,
oskar_mem_double_const(x_out, status),
oskar_mem_double_const(y_out, status),
oskar_mem_double_const(z_out, status),
oskar_mem_double4c_const(data, status),
offset_out,
oskar_mem_double4c(output, status), 0);
else
dftw_m2m_3d_float(num_in, (float)wavenumber,
oskar_mem_float2_const(weights_in, status),
oskar_mem_float_const(x_in, status),
oskar_mem_float_const(y_in, status),
oskar_mem_float_const(z_in, status),
offset_coord_out, num_out,
oskar_mem_float_const(x_out, status),
oskar_mem_float_const(y_out, status),
oskar_mem_float_const(z_out, status),
oskar_mem_float4c_const(data, status),
offset_out,
oskar_mem_float4c(output, status), 0);
}
else
{
if (is_dbl)
dftw_m2m_2d_double(num_in, wavenumber,
oskar_mem_double2_const(weights_in, status),
oskar_mem_double_const(x_in, status),
oskar_mem_double_const(y_in, status), 0,
offset_coord_out, num_out,
oskar_mem_double_const(x_out, status),
oskar_mem_double_const(y_out, status), 0,
oskar_mem_double4c_const(data, status),
offset_out,
oskar_mem_double4c(output, status), 0);
else
dftw_m2m_2d_float(num_in, (float)wavenumber,
oskar_mem_float2_const(weights_in, status),
oskar_mem_float_const(x_in, status),
oskar_mem_float_const(y_in, status), 0,
offset_coord_out, num_out,
oskar_mem_float_const(x_out, status),
oskar_mem_float_const(y_out, status), 0,
oskar_mem_float4c_const(data, status),
offset_out,
oskar_mem_float4c(output, status), 0);
}
}
else
{
if (is_3d)
{
if (is_dbl)
dftw_c2c_3d_double(num_in, wavenumber,
oskar_mem_double2_const(weights_in, status),
oskar_mem_double_const(x_in, status),
oskar_mem_double_const(y_in, status),
oskar_mem_double_const(z_in, status),
offset_coord_out, num_out,
oskar_mem_double_const(x_out, status),
oskar_mem_double_const(y_out, status),
oskar_mem_double_const(z_out, status),
oskar_mem_double2_const(data, status),
offset_out,
oskar_mem_double2(output, status), 0);
else
dftw_c2c_3d_float(num_in, (float)wavenumber,
oskar_mem_float2_const(weights_in, status),
oskar_mem_float_const(x_in, status),
oskar_mem_float_const(y_in, status),
oskar_mem_float_const(z_in, status),
offset_coord_out, num_out,
oskar_mem_float_const(x_out, status),
oskar_mem_float_const(y_out, status),
oskar_mem_float_const(z_out, status),
oskar_mem_float2_const(data, status),
offset_out,
oskar_mem_float2(output, status), 0);
}
else
{
if (is_dbl)
dftw_c2c_2d_double(num_in, wavenumber,
oskar_mem_double2_const(weights_in, status),
oskar_mem_double_const(x_in, status),
oskar_mem_double_const(y_in, status), 0,
offset_coord_out, num_out,
oskar_mem_double_const(x_out, status),
oskar_mem_double_const(y_out, status), 0,
oskar_mem_double2_const(data, status),
offset_out,
oskar_mem_double2(output, status), 0);
else
dftw_c2c_2d_float(num_in, (float)wavenumber,
oskar_mem_float2_const(weights_in, status),
oskar_mem_float_const(x_in, status),
oskar_mem_float_const(y_in, status), 0,
offset_coord_out, num_out,
oskar_mem_float_const(x_out, status),
oskar_mem_float_const(y_out, status), 0,
oskar_mem_float2_const(data, status),
offset_out,
oskar_mem_float2(output, status), 0);
}
}
}
else
{
if (is_3d)
{
if (is_dbl)
dftw_o2c_3d_double(num_in, wavenumber,
oskar_mem_double2_const(weights_in, status),
oskar_mem_double_const(x_in, status),
oskar_mem_double_const(y_in, status),
oskar_mem_double_const(z_in, status),
offset_coord_out, num_out,
oskar_mem_double_const(x_out, status),
oskar_mem_double_const(y_out, status),
oskar_mem_double_const(z_out, status),
0, offset_out,
oskar_mem_double2(output, status), 0);
else
dftw_o2c_3d_float(num_in, (float)wavenumber,
oskar_mem_float2_const(weights_in, status),
oskar_mem_float_const(x_in, status),
oskar_mem_float_const(y_in, status),
oskar_mem_float_const(z_in, status),
offset_coord_out, num_out,
oskar_mem_float_const(x_out, status),
oskar_mem_float_const(y_out, status),
oskar_mem_float_const(z_out, status),
0, offset_out,
oskar_mem_float2(output, status), 0);
}
else
{
if (is_dbl)
dftw_o2c_2d_double(num_in, wavenumber,
oskar_mem_double2_const(weights_in, status),
oskar_mem_double_const(x_in, status),
oskar_mem_double_const(y_in, status), 0,
offset_coord_out, num_out,
oskar_mem_double_const(x_out, status),
oskar_mem_double_const(y_out, status), 0,
0, offset_out,
oskar_mem_double2(output, status), 0);
else
dftw_o2c_2d_float(num_in, (float)wavenumber,
oskar_mem_float2_const(weights_in, status),
oskar_mem_float_const(x_in, status),
oskar_mem_float_const(y_in, status), 0,
offset_coord_out, num_out,
oskar_mem_float_const(x_out, status),
oskar_mem_float_const(y_out, status), 0,
0, offset_out,
oskar_mem_float2(output, status), 0);
}
}
}
else
{
size_t local_size[] = {256, 1, 1}, global_size[] = {1, 1, 1};
const void* np = 0;
const char* k = 0;
int max_in_chunk;
float wavenumber_f = (float) wavenumber;
/* Select the kernel. */
switch (is_dbl * DBL | is_3d * D3 | is_data * DAT | is_matrix * MAT)
{
case D2 | FLT: k = "dftw_o2c_2d_float"; break;
case D2 | DBL: k = "dftw_o2c_2d_double"; break;
case D3 | FLT: k = "dftw_o2c_3d_float"; break;
case D3 | DBL: k = "dftw_o2c_3d_double"; break;
case D2 | FLT | DAT: k = "dftw_c2c_2d_float"; break;
case D2 | DBL | DAT: k = "dftw_c2c_2d_double"; break;
case D3 | FLT | DAT: k = "dftw_c2c_3d_float"; break;
case D3 | DBL | DAT: k = "dftw_c2c_3d_double"; break;
case D2 | FLT | DAT | MAT: k = "dftw_m2m_2d_float"; break;
case D2 | DBL | DAT | MAT: k = "dftw_m2m_2d_double"; break;
case D3 | FLT | DAT | MAT: k = "dftw_m2m_3d_float"; break;
case D3 | DBL | DAT | MAT: k = "dftw_m2m_3d_double"; break;
default:
*status = OSKAR_ERR_FUNCTION_NOT_AVAILABLE;
return;
}
if (oskar_device_is_nv(location))
local_size[0] = (size_t) get_block_size(num_out);
oskar_device_check_local_size(location, 0, local_size);
global_size[0] = oskar_device_global_size(
(size_t) num_out, local_size[0]);
/* max_in_chunk must be multiple of 16. */
max_in_chunk = is_3d ? (is_dbl ? 384 : 800) : (is_dbl ? 448 : 896);
if (is_data && is_3d && !is_dbl) max_in_chunk = 768;
const size_t element_size = is_dbl ? sizeof(double) : sizeof(float);
const size_t local_mem_size = max_in_chunk * element_size;
const size_t arg_size_local[] = {
2 * local_mem_size, 2 * local_mem_size,
(is_3d ? local_mem_size : 0)
};
/* Set kernel arguments. */
const oskar_Arg args[] = {
{INT_SZ, &num_in},
{is_dbl ? DBL_SZ : FLT_SZ,
is_dbl ? (void*)&wavenumber : (void*)&wavenumber_f},
{PTR_SZ, oskar_mem_buffer_const(weights_in)},
{PTR_SZ, oskar_mem_buffer_const(x_in)},
{PTR_SZ, oskar_mem_buffer_const(y_in)},
{PTR_SZ, is_3d ? oskar_mem_buffer_const(z_in) : &np},
{INT_SZ, &offset_coord_out},
{INT_SZ, &num_out},
{PTR_SZ, oskar_mem_buffer_const(x_out)},
{PTR_SZ, oskar_mem_buffer_const(y_out)},
{PTR_SZ, is_3d ? oskar_mem_buffer_const(z_out) : &np},
{PTR_SZ, is_data ? oskar_mem_buffer_const(data) : &np},
{INT_SZ, &offset_out},
{PTR_SZ, oskar_mem_buffer(output)},
{INT_SZ, &max_in_chunk}
};
oskar_device_launch_kernel(k, location, 1, local_size, global_size,
sizeof(args) / sizeof(oskar_Arg), args,
sizeof(arg_size_local) / sizeof(size_t), arg_size_local,
status);
}
if (normalise)
oskar_mem_scale_real(output, 1. / num_in, offset_out, num_out, status);
}
/* Wrapper. */
void oskar_convert_ludwig3_to_theta_phi_components(oskar_Mem* vec,
int offset, int stride, int num_points, const oskar_Mem* phi,
int* status)
{
int type, location;
/* Check if safe to proceed. */
if (*status) return;
/* Check that the vector component data is in matrix form. */
if (!oskar_mem_is_matrix(vec))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
/* Get data type and location. */
type = oskar_mem_type(phi);
location = oskar_mem_location(phi);
/* Convert vector representation from Ludwig-3 to spherical. */
if (type == OSKAR_SINGLE)
{
float2 *h_theta, *v_phi;
const float *phi_;
h_theta = oskar_mem_float2(vec, status) + offset;
v_phi = oskar_mem_float2(vec, status) + offset + 1;
phi_ = oskar_mem_float_const(phi, status);
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_convert_ludwig3_to_theta_phi_components_cuda_f(num_points,
h_theta, v_phi, phi_, stride);
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
oskar_convert_ludwig3_to_theta_phi_components_f(num_points,
h_theta, v_phi, phi_, stride);
}
}
else if (type == OSKAR_DOUBLE)
{
double2 *h_theta, *v_phi;
const double *phi_;
h_theta = oskar_mem_double2(vec, status) + offset;
v_phi = oskar_mem_double2(vec, status) + offset + 1;
phi_ = oskar_mem_double_const(phi, status);
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_convert_ludwig3_to_theta_phi_components_cuda_d(num_points,
h_theta, v_phi, phi_, stride);
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
oskar_convert_ludwig3_to_theta_phi_components_d(num_points,
h_theta, v_phi, phi_, stride);
}
}
else
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
/* Wrapper. */
void oskar_evaluate_jones_K(oskar_Jones* K, int num_sources,
const oskar_Mem* l, const oskar_Mem* m, const oskar_Mem* n,
const oskar_Mem* u, const oskar_Mem* v, const oskar_Mem* w,
double frequency_hz, const oskar_Mem* source_filter,
double source_filter_min, double source_filter_max, int* status)
{
int num_stations, jones_type, base_type, location;
double wavenumber;
/* Check if safe to proceed. */
if (*status) return;
/* Get the Jones matrix block meta-data. */
jones_type = oskar_jones_type(K);
base_type = oskar_type_precision(jones_type);
location = oskar_jones_mem_location(K);
num_stations = oskar_jones_num_stations(K);
wavenumber = 2.0 * M_PI * frequency_hz / 299792458.0;
/* Check that the data is in the right location. */
if (oskar_mem_location(l) != location ||
oskar_mem_location(m) != location ||
oskar_mem_location(n) != location ||
oskar_mem_location(source_filter) != location ||
oskar_mem_location(u) != location ||
oskar_mem_location(v) != location ||
oskar_mem_location(w) != location)
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
/* Check that the data are of the right type. */
if (!oskar_type_is_complex(jones_type) ||
oskar_type_is_matrix(jones_type))
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
if (base_type != oskar_mem_type(l) || base_type != oskar_mem_type(m) ||
base_type != oskar_mem_type(n) || base_type != oskar_mem_type(u) ||
base_type != oskar_mem_type(v) || base_type != oskar_mem_type(w) ||
base_type != oskar_mem_type(source_filter))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
/* Evaluate Jones matrices. */
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
if (jones_type == OSKAR_SINGLE_COMPLEX)
{
oskar_evaluate_jones_K_cuda_f(oskar_jones_float2(K, status),
num_sources,
oskar_mem_float_const(l, status),
oskar_mem_float_const(m, status),
oskar_mem_float_const(n, status),
num_stations,
oskar_mem_float_const(u, status),
oskar_mem_float_const(v, status),
oskar_mem_float_const(w, status), wavenumber,
oskar_mem_float_const(source_filter, status),
source_filter_min, source_filter_max);
}
else if (jones_type == OSKAR_DOUBLE_COMPLEX)
{
oskar_evaluate_jones_K_cuda_d(oskar_jones_double2(K, status),
num_sources,
oskar_mem_double_const(l, status),
oskar_mem_double_const(m, status),
oskar_mem_double_const(n, status),
num_stations,
oskar_mem_double_const(u, status),
oskar_mem_double_const(v, status),
oskar_mem_double_const(w, status), wavenumber,
oskar_mem_double_const(source_filter, status),
source_filter_min, source_filter_max);
}
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
if (jones_type == OSKAR_SINGLE_COMPLEX)
{
oskar_evaluate_jones_K_f(oskar_jones_float2(K, status),
num_sources,
oskar_mem_float_const(l, status),
oskar_mem_float_const(m, status),
oskar_mem_float_const(n, status),
num_stations,
oskar_mem_float_const(u, status),
oskar_mem_float_const(v, status),
oskar_mem_float_const(w, status), wavenumber,
oskar_mem_float_const(source_filter, status),
source_filter_min, source_filter_max);
}
else if (jones_type == OSKAR_DOUBLE_COMPLEX)
{
oskar_evaluate_jones_K_d(oskar_jones_double2(K, status),
num_sources,
oskar_mem_double_const(l, status),
oskar_mem_double_const(m, status),
oskar_mem_double_const(n, status),
num_stations,
oskar_mem_double_const(u, status),
oskar_mem_double_const(v, status),
oskar_mem_double_const(w, status), wavenumber,
oskar_mem_double_const(source_filter, status),
source_filter_min, source_filter_max);
}
}
}
int main(int argc, char** argv)
{
// ===== Declare options ==================================================
oskar::OptionParser opt("oskar_vis_to_ascii_table", oskar_version_string());
opt.set_description("Converts an OSKAR visibility binary file to an ASCII "
"table format with the following columns:\n "
"[1] index, [2] baseline-uu, [3] baseline-vv, [4] baseline-ww "
"[5] Real, [6] Imag. "
"The table is written out in baseline-time order where baseline "
"is the fastest varying dimension");
opt.add_required("OSKAR vis file");
opt.add_optional("output file name");
opt.add_flag("-c", "Channel index to write to file. (default = 0)", 1, "0",
false, "--channel");
opt.add_flag("-p", "Polarisation ID to write to file. (default = 0) "
"(0=I, 1=Q, 2=U, 3=V, 4=XX, 5=XY, 6=YX, 7=YY)",
1, "0", false, "--polarisation");
opt.add_flag("-t", "Time index to write to file. (default = all)", 1, "",
false, "--time");
opt.add_flag("-w", "Output baseline coordinates in wavelengths. "
"(default = metres)", false, "--baseline_wavelengths");
opt.add_flag("-h", "Write a summary header in the ASCII table. ");
opt.add_flag("-v", "Verbose mode.");
opt.add_flag("--csv", "Write in CSV format");
opt.add_flag("-s", "Write output table to standard output instead of to file.",
false, "--stdout");
if (!opt.check_options(argc, argv)) return EXIT_FAILURE;
// ===== Read options ====================================================
const char* vis_file = opt.get_arg(0);
std::string txt_file;
if (opt.num_args() == 2)
txt_file = std::string(opt.get_arg(1));
else {
txt_file = std::string(vis_file) + ".txt";
}
int c = 0, p = 0, t = -1;
if (opt.is_set("-c")) c = opt.get_int("-c");
if (opt.is_set("-p")) p = opt.get_int("-p");
if (opt.is_set("-t")) t = opt.get_int("-t");
bool metres = !opt.is_set("-w");
bool write_header = opt.is_set("-h");
bool csv = opt.is_set("--csv");
bool verbose = opt.is_set("-v");
// ===== Write table ======================================================
int status = 0;
oskar_Binary* h = oskar_binary_create(vis_file, 'r', &status);
oskar_Vis* vis = oskar_vis_read(h, &status);
if (status)
{
fprintf(stderr, "ERROR: Unable to read specified visibility file: %s\n",
vis_file);
oskar_vis_free(vis, &status);
oskar_binary_free(h);
return status;
}
oskar_binary_free(h);
int num_chan = oskar_vis_num_channels(vis);
int num_times = oskar_vis_num_times(vis);
int num_baselines = oskar_vis_num_baselines(vis);
int num_pol = oskar_vis_num_pols(vis);
int num_stations = oskar_vis_num_stations(vis);
int total_vis = num_chan * num_times * num_baselines * num_pol;
double freq_start_hz = oskar_vis_freq_start_hz(vis);
double freq_inc_hz = oskar_vis_freq_inc_hz(vis);
double freq_hz = freq_start_hz + c * freq_inc_hz;
double lambda_m = 299792458.0 / freq_hz;
if (t != -1 && t > num_times-1) {
fprintf(stderr, "ERROR: Time index out of range.\n");
return EXIT_FAILURE;
}
if (c > num_chan-1) {
fprintf(stderr, "ERROR: Channel index out of range.\n");
return EXIT_FAILURE;
}
FILE* out;
if (!opt.is_set("-s")) {
out = fopen(txt_file.c_str(), "w");
if (out == NULL) return EXIT_FAILURE;
}
else {
out = stdout;
}
const oskar_Mem* uu = oskar_vis_baseline_uu_metres_const(vis);
const oskar_Mem* vv = oskar_vis_baseline_vv_metres_const(vis);
const oskar_Mem* ww = oskar_vis_baseline_ww_metres_const(vis);
const oskar_Mem* amp = oskar_vis_amplitude_const(vis);
// amplitudes dims: channel x times x baselines x pol
int amp_offset = c * num_times * num_baselines;
if (t != -1) amp_offset += t * num_baselines;
// baseline dims: times x baselines
int baseline_offset = 0;
if (t != -1) baseline_offset = t * num_baselines;
int type = oskar_mem_type(uu);
int num_vis_out = num_baselines;
if (t == -1) num_vis_out *= num_times;
if (verbose) {
write_header_(stdout, total_vis, num_chan, num_times, num_baselines,
num_pol, num_stations, num_vis_out, c, freq_hz, lambda_m, p, t,
metres);
#if 0
fprintf(stdout, "amp_offset = %i\n", amp_offset);
fprintf(stdout, "baseline_offset = %i\n", baseline_offset);
#endif
}
// Write header if specified
if (write_header)
{
write_header_(out, total_vis, num_chan, num_times, num_baselines,
num_pol, num_stations, num_vis_out, c, freq_hz, lambda_m, p, t,
metres);
char pre = '#';
fprintf(out, "%c\n", pre);
fprintf(out, "%c %s %-14s %-15s %-15s %-23s %-15s\n",
pre, "Idx", " uu", " vv", " ww", " Amp. Re.", " Amp. Im.");
}
if (type == OSKAR_DOUBLE)
{
const double* uu_ = oskar_mem_double_const(uu, &status);
const double* vv_ = oskar_mem_double_const(vv, &status);
const double* ww_ = oskar_mem_double_const(ww, &status);
const double4c* amp_ = oskar_mem_double4c_const(amp, &status);
int aIdx = amp_offset;
int bIdx = baseline_offset;
for (int i = 0; i < num_vis_out; ++i, ++bIdx, ++aIdx)
{
double2 a = getPolAmp_<double2, double4c>(amp_[aIdx], p);
double buu = (metres)? uu_[bIdx] : uu_[bIdx]/lambda_m;
double bvv = (metres)? vv_[bIdx] : vv_[bIdx]/lambda_m;
double bww = (metres)? ww_[bIdx] : ww_[bIdx]/lambda_m;
writeData_<double, double2>(i, buu, bvv, bww, a, csv, out);
}
}
else // OSKAR_SINGLE
{
const float* uu_ = oskar_mem_float_const(uu, &status);
const float* vv_ = oskar_mem_float_const(vv, &status);
const float* ww_ = oskar_mem_float_const(ww, &status);
const float4c* amp_ = oskar_mem_float4c_const(amp, &status);
int aIdx = amp_offset;
int bIdx = baseline_offset;
for (int i = 0; i < num_vis_out; ++i, ++bIdx, ++aIdx)
{
float2 a = getPolAmp_<float2, float4c>(amp_[aIdx], p);
float buu = (metres)? uu_[bIdx] : uu_[bIdx]/lambda_m;
float bvv = (metres)? vv_[bIdx] : vv_[bIdx]/lambda_m;
float bww = (metres)? ww_[bIdx] : ww_[bIdx]/lambda_m;
writeData_<float, float2>(i, buu, bvv, bww, a, csv, out);
}
}
fclose(out);
oskar_vis_free(vis, &status);
return status;
}
void oskar_imager_read_coords_ms(oskar_Imager* h, const char* filename,
int i_file, int num_files, int* percent_done, int* percent_next,
int* status)
{
#ifndef OSKAR_NO_MS
oskar_MeasurementSet* ms;
oskar_Mem *uvw, *u, *v, *w, *weight, *time_centroid;
int num_channels, num_stations, num_baselines, num_pols;
int start_row, num_rows;
double *uvw_, *u_, *v_, *w_;
if (*status) return;
/* Read the header. */
ms = oskar_ms_open(filename);
if (!ms)
{
*status = OSKAR_ERR_FILE_IO;
return;
}
num_rows = (int) oskar_ms_num_rows(ms);
num_stations = (int) oskar_ms_num_stations(ms);
num_baselines = num_stations * (num_stations - 1) / 2;
num_pols = (int) oskar_ms_num_pols(ms);
num_channels = (int) oskar_ms_num_channels(ms);
/* Set visibility meta-data. */
oskar_imager_set_vis_frequency(h,
oskar_ms_freq_start_hz(ms),
oskar_ms_freq_inc_hz(ms), num_channels);
oskar_imager_set_vis_phase_centre(h,
oskar_ms_phase_centre_ra_rad(ms) * 180/M_PI,
oskar_ms_phase_centre_dec_rad(ms) * 180/M_PI);
/* Create arrays. */
uvw = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 3 * num_baselines, status);
u = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, num_baselines, status);
v = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, num_baselines, status);
w = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, num_baselines, status);
weight = oskar_mem_create(OSKAR_SINGLE, OSKAR_CPU,
num_baselines * num_pols, status);
time_centroid = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, num_baselines,
status);
uvw_ = oskar_mem_double(uvw, status);
u_ = oskar_mem_double(u, status);
v_ = oskar_mem_double(v, status);
w_ = oskar_mem_double(w, status);
/* Loop over visibility blocks. */
for (start_row = 0; start_row < num_rows; start_row += num_baselines)
{
int i, block_size;
size_t allocated, required;
if (*status) break;
/* Read coordinates and weights from Measurement Set. */
oskar_timer_resume(h->tmr_read);
block_size = num_rows - start_row;
if (block_size > num_baselines) block_size = num_baselines;
allocated = oskar_mem_length(uvw) *
oskar_mem_element_size(oskar_mem_type(uvw));
oskar_ms_read_column(ms, "UVW", start_row, block_size,
allocated, oskar_mem_void(uvw), &required, status);
allocated = oskar_mem_length(weight) *
oskar_mem_element_size(oskar_mem_type(weight));
oskar_ms_read_column(ms, "WEIGHT", start_row, block_size,
allocated, oskar_mem_void(weight), &required, status);
allocated = oskar_mem_length(time_centroid) *
oskar_mem_element_size(oskar_mem_type(time_centroid));
oskar_ms_read_column(ms, "TIME_CENTROID", start_row, block_size,
allocated, oskar_mem_void(time_centroid), &required, status);
/* Split up baseline coordinates. */
for (i = 0; i < block_size; ++i)
{
u_[i] = uvw_[3*i + 0];
v_[i] = uvw_[3*i + 1];
w_[i] = uvw_[3*i + 2];
}
/* Update the imager with the data. */
oskar_timer_pause(h->tmr_read);
oskar_imager_update(h, block_size, 0, num_channels - 1, num_pols,
u, v, w, 0, weight, time_centroid, status);
*percent_done = (int) round(100.0 * (
(start_row + block_size) / (double)(num_rows * num_files) +
i_file / (double)num_files));
if (h->log && percent_next && *percent_done >= *percent_next)
{
oskar_log_message(h->log, 'S', -2, "%3d%% ...", *percent_done);
*percent_next = 10 + 10 * (*percent_done / 10);
}
}
oskar_mem_free(uvw, status);
oskar_mem_free(u, status);
oskar_mem_free(v, status);
oskar_mem_free(w, status);
oskar_mem_free(weight, status);
oskar_mem_free(time_centroid, status);
oskar_ms_close(ms);
#else
(void) filename;
(void) i_file;
(void) num_files;
(void) percent_done;
(void) percent_next;
oskar_log_error(h->log, "OSKAR was compiled without Measurement Set support.");
*status = OSKAR_ERR_FUNCTION_NOT_AVAILABLE;
#endif
}
int oskar_sph_rotate_to_position(int n, oskar_Mem* lon, oskar_Mem* lat,
double lon0, double lat0)
{
int i;
if (lon == NULL || lat == NULL)
return OSKAR_ERR_INVALID_ARGUMENT;
if (oskar_mem_location(lon) != OSKAR_CPU || oskar_mem_location(lat) != OSKAR_CPU)
return OSKAR_ERR_BAD_LOCATION;
if (oskar_mem_type(lon) == OSKAR_DOUBLE && oskar_mem_type(lat) == OSKAR_DOUBLE)
{
/* Construct rotation matrix. */
double cosLon, sinLon, cosLat, sinLat;
double m11, m12, m13, m21, m22, m23, m31, m33;
cosLon = cos(lon0);
sinLon = sin(lon0);
cosLat = cos(lat0);
sinLat = sin(lat0);
m11 = cosLon * sinLat; m12 = -sinLon; m13 = cosLon * cosLat;
m21 = sinLon * sinLat; m22 = cosLon; m23 = sinLon * cosLat;
m31 = -cosLat; m33 = sinLat;
for (i = 0; i < n; ++i)
{
double x, y, z, a, b, c;
/* Direction cosines */
c = cos(((double*)lat->data)[i]);
x = c * cos(((double*)lon->data)[i]);
y = c * sin(((double*)lon->data)[i]);
z = sin(((double*)lat->data)[i]);
/* Apply rotation matrix */
a = m11 * x + m12 * y + m13 * z;
b = m21 * x + m22 * y + m23 * z;
c = m31 * x + m33 * z;
/* Convert back to angles. */
((double*)lon->data)[i] = atan2(b, a);
((double*)lat->data)[i] = atan2(c, sqrt(a*a + b*b));
}
}
else if (oskar_mem_type(lon) == OSKAR_SINGLE && oskar_mem_type(lat) == OSKAR_SINGLE)
{
/* Construct rotation matrix. */
float cosLon, sinLon, cosLat, sinLat;
float m11, m12, m13, m21, m22, m23, m31, m33;
cosLon = cosf(lon0);
sinLon = sinf(lon0);
cosLat = cosf(lat0);
sinLat = sinf(lat0);
m11 = cosLon * sinLat; m12 = -sinLon; m13 = cosLon * cosLat;
m21 = sinLon * sinLat; m22 = cosLon; m23 = sinLon * cosLat;
m31 = -cosLat; m33 = sinLat;
for (i = 0; i < n; ++i)
{
float x, y, z, a, b, c;
/* Direction cosines */
c = cosf(((float*)lat->data)[i]);
x = c * cosf(((float*)lon->data)[i]);
y = c * sinf(((float*)lon->data)[i]);
z = sinf(((float*)lat->data)[i]);
/* Apply rotation matrix */
a = m11 * x + m12 * y + m13 * z;
b = m21 * x + m22 * y + m23 * z;
c = m31 * x + m33 * z;
/* Convert back to angles. */
((float*)lon->data)[i] = atan2f(b, a);
((float*)lat->data)[i] = atan2f(c, sqrtf(a*a + b*b));
}
}
else
{
return OSKAR_ERR_BAD_DATA_TYPE;
}
return 0;
}
void oskar_auto_correlate(oskar_Mem* vis, int n_sources, const oskar_Jones* J,
const oskar_Sky* sky, int* status)
{
int jones_type, base_type, location, matrix_type, n_stations;
/* Check if safe to proceed. */
if (*status) return;
/* Get the data dimensions. */
n_stations = oskar_jones_num_stations(J);
/* Check data locations. */
location = oskar_sky_mem_location(sky);
if (oskar_jones_mem_location(J) != location ||
oskar_mem_location(vis) != location)
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
/* Check for consistent data types. */
jones_type = oskar_jones_type(J);
base_type = oskar_sky_precision(sky);
matrix_type = oskar_type_is_matrix(jones_type) &&
oskar_mem_is_matrix(vis);
if (oskar_mem_precision(vis) != base_type ||
oskar_type_precision(jones_type) != base_type)
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if (oskar_mem_type(vis) != jones_type)
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
/* If neither single or double precision, return error. */
if (base_type != OSKAR_SINGLE && base_type != OSKAR_DOUBLE)
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
/* Check the input dimensions. */
if (oskar_jones_num_sources(J) < n_sources)
{
*status = OSKAR_ERR_DIMENSION_MISMATCH;
return;
}
/* Select kernel. */
if (base_type == OSKAR_DOUBLE)
{
const double *I_, *Q_, *U_, *V_;
I_ = oskar_mem_double_const(oskar_sky_I_const(sky), status);
Q_ = oskar_mem_double_const(oskar_sky_Q_const(sky), status);
U_ = oskar_mem_double_const(oskar_sky_U_const(sky), status);
V_ = oskar_mem_double_const(oskar_sky_V_const(sky), status);
if (matrix_type)
{
double4c *vis_;
const double4c *J_;
vis_ = oskar_mem_double4c(vis, status);
J_ = oskar_jones_double4c_const(J, status);
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_auto_correlate_cuda_d(n_sources, n_stations,
J_, I_, Q_, U_, V_, vis_);
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else /* CPU */
{
oskar_auto_correlate_omp_d(n_sources, n_stations,
J_, I_, Q_, U_, V_, vis_);
}
}
else /* Scalar version. */
{
double2 *vis_;
const double2 *J_;
vis_ = oskar_mem_double2(vis, status);
J_ = oskar_jones_double2_const(J, status);
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_auto_correlate_scalar_cuda_d(n_sources, n_stations,
J_, I_, vis_);
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else /* CPU */
{
oskar_auto_correlate_scalar_omp_d(n_sources, n_stations,
J_, I_, vis_);
}
}
}
else /* Single precision. */
{
const float *I_, *Q_, *U_, *V_;
I_ = oskar_mem_float_const(oskar_sky_I_const(sky), status);
Q_ = oskar_mem_float_const(oskar_sky_Q_const(sky), status);
U_ = oskar_mem_float_const(oskar_sky_U_const(sky), status);
V_ = oskar_mem_float_const(oskar_sky_V_const(sky), status);
if (matrix_type)
{
float4c *vis_;
const float4c *J_;
vis_ = oskar_mem_float4c(vis, status);
J_ = oskar_jones_float4c_const(J, status);
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_auto_correlate_cuda_f(n_sources, n_stations,
J_, I_, Q_, U_, V_, vis_);
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else /* CPU */
{
oskar_auto_correlate_omp_f(n_sources, n_stations,
J_, I_, Q_, U_, V_, vis_);
}
}
else /* Scalar version. */
{
float2 *vis_;
const float2 *J_;
vis_ = oskar_mem_float2(vis, status);
J_ = oskar_jones_float2_const(J, status);
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_auto_correlate_scalar_cuda_f(n_sources, n_stations,
J_, I_, vis_);
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else /* CPU */
{
oskar_auto_correlate_scalar_omp_f(n_sources, n_stations,
J_, I_, vis_);
}
}
}
}
void oskar_gaussian_circular(int num_points,
const oskar_Mem* l, const oskar_Mem* m, double std,
oskar_Mem* out, int* status)
{
if (*status) return;
const int location = oskar_mem_location(out);
const double inv_2_var = 1.0 / (2.0 * std * std);
const float inv_2_var_f = (float)inv_2_var;
if (oskar_mem_precision(out) != oskar_mem_type(l) ||
oskar_mem_precision(out) != oskar_mem_type(m))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if (location != oskar_mem_location(l) || location != oskar_mem_location(m))
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
if ((int)oskar_mem_length(l) < num_points ||
(int)oskar_mem_length(m) < num_points)
{
*status = OSKAR_ERR_DIMENSION_MISMATCH;
return;
}
oskar_mem_ensure(out, num_points, status);
if (*status) return;
if (location == OSKAR_CPU)
{
switch (oskar_mem_type(out))
{
case OSKAR_SINGLE_COMPLEX:
gaussian_circular_complex_f(num_points,
oskar_mem_float_const(l, status),
oskar_mem_float_const(m, status), inv_2_var_f,
oskar_mem_float2(out, status));
break;
case OSKAR_DOUBLE_COMPLEX:
gaussian_circular_complex_d(num_points,
oskar_mem_double_const(l, status),
oskar_mem_double_const(m, status), inv_2_var,
oskar_mem_double2(out, status));
break;
case OSKAR_SINGLE_COMPLEX_MATRIX:
gaussian_circular_matrix_f(num_points,
oskar_mem_float_const(l, status),
oskar_mem_float_const(m, status), inv_2_var_f,
oskar_mem_float4c(out, status));
break;
case OSKAR_DOUBLE_COMPLEX_MATRIX:
gaussian_circular_matrix_d(num_points,
oskar_mem_double_const(l, status),
oskar_mem_double_const(m, status), inv_2_var,
oskar_mem_double4c(out, status));
break;
default:
*status = OSKAR_ERR_BAD_DATA_TYPE;
break;
}
}
else
{
size_t local_size[] = {256, 1, 1}, global_size[] = {1, 1, 1};
const char* k = 0;
const int is_dbl = oskar_mem_is_double(out);
switch (oskar_mem_type(out))
{
case OSKAR_SINGLE_COMPLEX:
k = "gaussian_circular_complex_float"; break;
case OSKAR_DOUBLE_COMPLEX:
k = "gaussian_circular_complex_double"; break;
case OSKAR_SINGLE_COMPLEX_MATRIX:
k = "gaussian_circular_matrix_float"; break;
case OSKAR_DOUBLE_COMPLEX_MATRIX:
k = "gaussian_circular_matrix_double"; break;
default:
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
oskar_device_check_local_size(location, 0, local_size);
global_size[0] = oskar_device_global_size(
(size_t) num_points, local_size[0]);
const oskar_Arg args[] = {
{INT_SZ, &num_points},
{PTR_SZ, oskar_mem_buffer_const(l)},
{PTR_SZ, oskar_mem_buffer_const(m)},
{is_dbl ? DBL_SZ : FLT_SZ, is_dbl ?
(const void*)&inv_2_var : (const void*)&inv_2_var_f},
{PTR_SZ, oskar_mem_buffer(out)}
};
oskar_device_launch_kernel(k, location, 1, local_size, global_size,
sizeof(args) / sizeof(oskar_Arg), args, 0, 0, status);
}
}
void oskar_splines_evaluate(const oskar_Splines* spline,
int num_points, const oskar_Mem* x, const oskar_Mem* y,
int stride_out, int offset_out, oskar_Mem* output, int* status)
{
if (*status) return;
const int type = oskar_splines_precision(spline);
const int location = oskar_splines_mem_location(spline);
const int nx = oskar_splines_num_knots_x_theta(spline);
const int ny = oskar_splines_num_knots_y_phi(spline);
const oskar_Mem* tx = oskar_splines_knots_x_theta_const(spline);
const oskar_Mem* ty = oskar_splines_knots_y_phi_const(spline);
const oskar_Mem* coeff = oskar_splines_coeff_const(spline);
if (type != oskar_mem_type(x) || type != oskar_mem_type(y))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if (location != oskar_mem_location(output) ||
location != oskar_mem_location(x) ||
location != oskar_mem_location(y))
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
if (location == OSKAR_CPU)
{
int i;
if (type == OSKAR_SINGLE)
{
const float *tx_, *ty_, *coeff_, *x_, *y_;
float *out;
tx_ = oskar_mem_float_const(tx, status);
ty_ = oskar_mem_float_const(ty, status);
coeff_ = oskar_mem_float_const(coeff, status);
x_ = oskar_mem_float_const(x, status);
y_ = oskar_mem_float_const(y, status);
out = oskar_mem_float(output, status) + offset_out;
if (nx == 0 || ny == 0 || !tx_ || !ty_ || !coeff_)
for (i = 0; i < num_points; ++i) out[i * stride_out] = 0.0f;
else
{
float x1, y1, wrk[8];
int iwrk1[2], kwrk1 = 2, lwrk = 8, err = 0;
for (i = 0; i < num_points; ++i)
{
x1 = x_[i];
y1 = y_[i];
oskar_dierckx_bispev_f(tx_, nx, ty_, ny, coeff_, 3, 3,
&x1, 1, &y1, 1, &out[i * stride_out],
wrk, lwrk, iwrk1, kwrk1, &err);
if (err != 0)
{
*status = OSKAR_ERR_SPLINE_EVAL_FAIL;
return;
}
}
}
}
else if (type == OSKAR_DOUBLE)
{
const double *tx_, *ty_, *coeff_, *x_, *y_;
double *out;
tx_ = oskar_mem_double_const(tx, status);
ty_ = oskar_mem_double_const(ty, status);
coeff_ = oskar_mem_double_const(coeff, status);
x_ = oskar_mem_double_const(x, status);
y_ = oskar_mem_double_const(y, status);
out = oskar_mem_double(output, status) + offset_out;
if (nx == 0 || ny == 0 || !tx_ || !ty_ || !coeff_)
for (i = 0; i < num_points; ++i) out[i * stride_out] = 0.0;
else
{
double x1, y1, wrk[8];
int iwrk1[2], kwrk1 = 2, lwrk = 8, err = 0;
for (i = 0; i < num_points; ++i)
{
x1 = x_[i];
y1 = y_[i];
oskar_dierckx_bispev_d(tx_, nx, ty_, ny, coeff_, 3, 3,
&x1, 1, &y1, 1, &out[i * stride_out],
wrk, lwrk, iwrk1, kwrk1, &err);
if (err != 0)
{
*status = OSKAR_ERR_SPLINE_EVAL_FAIL;
return;
}
}
}
}
else
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
else
{
size_t local_size[] = {256, 1, 1}, global_size[] = {1, 1, 1};
const char* k = 0;
if (nx == 0 || ny == 0)
{
if (type == OSKAR_DOUBLE) k = "set_zeros_stride_double";
else if (type == OSKAR_SINGLE) k = "set_zeros_stride_float";
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
oskar_device_check_local_size(location, 0, local_size);
global_size[0] = oskar_device_global_size(
(size_t) num_points, local_size[0]);
const oskar_Arg args[] = {
{INT_SZ, &num_points},
{INT_SZ, &stride_out},
{INT_SZ, &offset_out},
{PTR_SZ, oskar_mem_buffer(output)}
};
oskar_device_launch_kernel(k, location, 1, local_size, global_size,
sizeof(args) / sizeof(oskar_Arg), args, 0, 0, status);
}
else
{
if (type == OSKAR_DOUBLE) k = "dierckx_bispev_bicubic_double";
else if (type == OSKAR_SINGLE) k = "dierckx_bispev_bicubic_float";
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
oskar_device_check_local_size(location, 0, local_size);
global_size[0] = oskar_device_global_size(
(size_t) num_points, local_size[0]);
const oskar_Arg args[] = {
{PTR_SZ, oskar_mem_buffer_const(tx)},
{INT_SZ, &nx},
{PTR_SZ, oskar_mem_buffer_const(ty)},
{INT_SZ, &ny},
{PTR_SZ, oskar_mem_buffer_const(coeff)},
{INT_SZ, &num_points},
{PTR_SZ, oskar_mem_buffer_const(x)},
{PTR_SZ, oskar_mem_buffer_const(y)},
{INT_SZ, &stride_out},
{INT_SZ, &offset_out},
{PTR_SZ, oskar_mem_buffer(output)}
};
oskar_device_launch_kernel(k, location, 1, local_size, global_size,
sizeof(args) / sizeof(oskar_Arg), args, 0, 0, status);
}
}
}
/* Wrapper. */
void oskar_convert_enu_directions_to_theta_phi(int num_points,
const oskar_Mem* x, const oskar_Mem* y, const oskar_Mem* z,
double delta_phi, oskar_Mem* theta, oskar_Mem* phi, int* status)
{
int type, location;
/* Check if safe to proceed. */
if (*status) return;
/* Get data type and location. */
type = oskar_mem_type(theta);
location = oskar_mem_location(theta);
/* Compute modified theta and phi coordinates. */
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
if (type == OSKAR_SINGLE)
{
oskar_convert_enu_directions_to_theta_phi_cuda_f(num_points,
oskar_mem_float_const(x, status),
oskar_mem_float_const(y, status),
oskar_mem_float_const(z, status), (float)delta_phi,
oskar_mem_float(theta, status),
oskar_mem_float(phi, status));
oskar_device_check_error(status);
}
else if (type == OSKAR_DOUBLE)
{
oskar_convert_enu_directions_to_theta_phi_cuda_d(num_points,
oskar_mem_double_const(x, status),
oskar_mem_double_const(y, status),
oskar_mem_double_const(z, status), delta_phi,
oskar_mem_double(theta, status),
oskar_mem_double(phi, status));
oskar_device_check_error(status);
}
else
*status = OSKAR_ERR_BAD_DATA_TYPE;
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
if (type == OSKAR_SINGLE)
{
oskar_convert_enu_directions_to_theta_phi_f(num_points,
oskar_mem_float_const(x, status),
oskar_mem_float_const(y, status),
oskar_mem_float_const(z, status), (float)delta_phi,
oskar_mem_float(theta, status),
oskar_mem_float(phi, status));
}
else if (type == OSKAR_DOUBLE)
{
oskar_convert_enu_directions_to_theta_phi_d(num_points,
oskar_mem_double_const(x, status),
oskar_mem_double_const(y, status),
oskar_mem_double_const(z, status), delta_phi,
oskar_mem_double(theta, status),
oskar_mem_double(phi, status));
}
else
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
}
void oskar_blank_below_horizon(int offset_mask, int num_sources,
const oskar_Mem* mask, int offset_out, oskar_Mem* data, int* status)
{
if (*status) return;
const int location = oskar_mem_location(data);
if (oskar_mem_location(mask) != location)
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
if (oskar_mem_type(mask) != oskar_mem_precision(data))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if ((int)oskar_mem_length(data) < num_sources)
{
*status = OSKAR_ERR_DIMENSION_MISMATCH;
return;
}
if (location == OSKAR_CPU)
{
switch (oskar_mem_type(data))
{
case OSKAR_DOUBLE_COMPLEX_MATRIX:
blank_below_horizon_matrix_d(offset_mask, num_sources,
oskar_mem_double_const(mask, status), offset_out,
oskar_mem_double4c(data, status));
break;
case OSKAR_DOUBLE_COMPLEX:
blank_below_horizon_scalar_d(offset_mask, num_sources,
oskar_mem_double_const(mask, status), offset_out,
oskar_mem_double2(data, status));
break;
case OSKAR_SINGLE_COMPLEX_MATRIX:
blank_below_horizon_matrix_f(offset_mask, num_sources,
oskar_mem_float_const(mask, status), offset_out,
oskar_mem_float4c(data, status));
break;
case OSKAR_SINGLE_COMPLEX:
blank_below_horizon_scalar_f(offset_mask, num_sources,
oskar_mem_float_const(mask, status), offset_out,
oskar_mem_float2(data, status));
break;
default:
*status = OSKAR_ERR_BAD_DATA_TYPE;
break;
}
}
else
{
size_t local_size[] = {256, 1, 1}, global_size[] = {1, 1, 1};
const char* k = 0;
switch (oskar_mem_type(data))
{
case OSKAR_DOUBLE_COMPLEX_MATRIX:
k = "blank_below_horizon_matrix_double"; break;
case OSKAR_DOUBLE_COMPLEX:
k = "blank_below_horizon_scalar_double"; break;
case OSKAR_SINGLE_COMPLEX_MATRIX:
k = "blank_below_horizon_matrix_float"; break;
case OSKAR_SINGLE_COMPLEX:
k = "blank_below_horizon_scalar_float"; break;
default:
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
oskar_device_check_local_size(location, 0, local_size);
global_size[0] = oskar_device_global_size(
(size_t) num_sources, local_size[0]);
const oskar_Arg args[] = {
{INT_SZ, &offset_mask},
{INT_SZ, &num_sources},
{PTR_SZ, oskar_mem_buffer_const(mask)},
{INT_SZ, &offset_out},
{PTR_SZ, oskar_mem_buffer(data)}
};
oskar_device_launch_kernel(k, location, 1, local_size, global_size,
sizeof(args) / sizeof(oskar_Arg), args, 0, 0, status);
}
}
/* Wrapper. */
void oskar_convert_ecef_to_station_uvw(int num_stations, const oskar_Mem* x,
const oskar_Mem* y, const oskar_Mem* z, double ra0_rad,
double dec0_rad, double gast, oskar_Mem* u, oskar_Mem* v,
oskar_Mem* w, int* status)
{
int type, location;
double ha0_rad;
/* Check if safe to proceed. */
if (*status) return;
/* Get data type and location of the input coordinates. */
type = oskar_mem_type(x);
location = oskar_mem_location(x);
/* Check that the memory is allocated. */
if (!oskar_mem_allocated(u) || !oskar_mem_allocated(v) ||
!oskar_mem_allocated(w) || !oskar_mem_allocated(x) ||
!oskar_mem_allocated(y) || !oskar_mem_allocated(z))
{
*status = OSKAR_ERR_MEMORY_NOT_ALLOCATED;
return;
}
/* Check that the data dimensions are OK. */
if ((int)oskar_mem_length(u) < num_stations ||
(int)oskar_mem_length(v) < num_stations ||
(int)oskar_mem_length(w) < num_stations ||
(int)oskar_mem_length(x) < num_stations ||
(int)oskar_mem_length(y) < num_stations ||
(int)oskar_mem_length(z) < num_stations)
{
*status = OSKAR_ERR_DIMENSION_MISMATCH;
return;
}
/* Check that the data are in the right location. */
if (oskar_mem_location(y) != location ||
oskar_mem_location(z) != location ||
oskar_mem_location(u) != location ||
oskar_mem_location(v) != location ||
oskar_mem_location(w) != location)
{
*status = OSKAR_ERR_BAD_LOCATION;
return;
}
/* Check that the data is of the right type. */
if (oskar_mem_type(y) != type || oskar_mem_type(z) != type ||
oskar_mem_type(u) != type || oskar_mem_type(v) != type ||
oskar_mem_type(w) != type)
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
/* Evaluate Greenwich Hour Angle of phase centre. */
ha0_rad = gast - ra0_rad;
/* Evaluate station u,v,w coordinates. */
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
if (type == OSKAR_SINGLE)
{
oskar_convert_ecef_to_station_uvw_cuda_f(num_stations,
oskar_mem_float_const(x, status),
oskar_mem_float_const(y, status),
oskar_mem_float_const(z, status),
(float)ha0_rad, (float)dec0_rad,
oskar_mem_float(u, status),
oskar_mem_float(v, status),
oskar_mem_float(w, status));
}
else if (type == OSKAR_DOUBLE)
{
oskar_convert_ecef_to_station_uvw_cuda_d(num_stations,
oskar_mem_double_const(x, status),
oskar_mem_double_const(y, status),
oskar_mem_double_const(z, status),
ha0_rad, dec0_rad,
oskar_mem_double(u, status),
oskar_mem_double(v, status),
oskar_mem_double(w, status));
}
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
if (type == OSKAR_SINGLE)
{
oskar_convert_ecef_to_station_uvw_f(num_stations,
oskar_mem_float_const(x, status),
oskar_mem_float_const(y, status),
oskar_mem_float_const(z, status),
(float)ha0_rad, (float)dec0_rad,
oskar_mem_float(u, status),
oskar_mem_float(v, status),
oskar_mem_float(w, status));
}
else if (type == OSKAR_DOUBLE)
{
oskar_convert_ecef_to_station_uvw_d(num_stations,
oskar_mem_double_const(x, status),
oskar_mem_double_const(y, status),
oskar_mem_double_const(z, status),
ha0_rad, dec0_rad,
oskar_mem_double(u, status),
oskar_mem_double(v, status),
oskar_mem_double(w, status));
}
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
}
else
{
*status = OSKAR_ERR_BAD_LOCATION;
}
}
void oskar_evaluate_tec_tid(oskar_Mem* tec, int num_directions,
const oskar_Mem* lon, const oskar_Mem* lat,
const oskar_Mem* rel_path_length, double TEC0,
oskar_SettingsTIDscreen* TID, double gast)
{
int i, j, type;
double pp_lon, pp_lat;
double pp_sec;
double pp_tec;
double amp, w, th, v; /* TID parameters */
double time;
double earth_radius = 6365.0; /* km -- FIXME */
int status = 0;
/* TODO check types, dimensions etc of memory */
type = oskar_mem_type(tec);
oskar_mem_set_value_real(tec, 0.0, 0, 0, &status);
/* Loop over TIDs */
for (i = 0; i < TID->num_components; ++i)
{
amp = TID->amp[i];
/* convert from km to rads */
w = TID->wavelength[i] / (earth_radius + TID->height_km);
th = TID->theta[i] * M_PI/180.;
/* convert from km/h to rad/s */
v = (TID->speed[i]/(earth_radius + TID->height_km)) / 3600;
time = gast * 86400.0; /* days->sec */
/* Loop over directions */
for (j = 0; j < num_directions; ++j)
{
if (type == OSKAR_DOUBLE)
{
pp_lon = oskar_mem_double_const(lon, &status)[j];
pp_lat = oskar_mem_double_const(lat, &status)[j];
pp_sec = oskar_mem_double_const(rel_path_length, &status)[j];
pp_tec = pp_sec * amp * TEC0 * (
cos( (2.0*M_PI/w) * (cos(th)*pp_lon - v*time) ) +
cos( (2.0*M_PI/w) * (sin(th)*pp_lat - v*time) )
);
pp_tec += TEC0;
oskar_mem_double(tec, &status)[j] += pp_tec;
}
else
{
pp_lon = (double)oskar_mem_float_const(lon, &status)[j];
pp_lat = (double)oskar_mem_float_const(lat, &status)[j];
pp_sec = (double)oskar_mem_float_const(rel_path_length, &status)[j];
pp_tec = pp_sec * amp * TEC0 * (
cos( (2.0*M_PI/w) * (cos(th)*pp_lon - v*time) ) +
cos( (2.0*M_PI/w) * (sin(th)*pp_lat - v*time) )
);
pp_tec += TEC0;
oskar_mem_float(tec, &status)[j] += (float)pp_tec;
}
} /* loop over directions */
} /* loop over components. */
}
int oskar_work_jones_z_type(oskar_WorkJonesZ* work)
{
if (oskar_mem_type(work->hor_x) == OSKAR_DOUBLE &&
oskar_mem_type(work->hor_y) == OSKAR_DOUBLE &&
oskar_mem_type(work->hor_z) == OSKAR_DOUBLE &&
oskar_mem_type(work->pp_lon) == OSKAR_DOUBLE &&
oskar_mem_type(work->pp_lat) == OSKAR_DOUBLE &&
oskar_mem_type(work->pp_rel_path) == OSKAR_DOUBLE &&
oskar_mem_type(work->screen_TEC) == OSKAR_DOUBLE &&
oskar_mem_type(work->total_TEC) == OSKAR_DOUBLE)
{
return OSKAR_DOUBLE;
}
else if (oskar_mem_type(work->hor_x) == OSKAR_SINGLE &&
oskar_mem_type(work->hor_y) == OSKAR_SINGLE &&
oskar_mem_type(work->hor_z) == OSKAR_SINGLE &&
oskar_mem_type(work->pp_lon) == OSKAR_SINGLE &&
oskar_mem_type(work->pp_lat) == OSKAR_SINGLE &&
oskar_mem_type(work->pp_rel_path) == OSKAR_SINGLE &&
oskar_mem_type(work->screen_TEC) == OSKAR_SINGLE &&
oskar_mem_type(work->total_TEC) == OSKAR_SINGLE)
{
return OSKAR_SINGLE;
}
return -1;
}
void oskar_evaluate_vla_beam_pbcor(oskar_Mem* beam, int num_sources,
const oskar_Mem* l, const oskar_Mem* m, double frequency_hz,
int* status)
{
int index, precision, type, location;
double f, p1, p2, p3;
/* Check if safe to proceed. */
if (*status) return;
/* Check type and location. */
precision = oskar_mem_precision(beam);
type = oskar_mem_type(beam);
location = oskar_mem_location(beam);
if (precision != oskar_mem_type(l) || precision != oskar_mem_type(m))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if (location != oskar_mem_location(l) || location != oskar_mem_location(m))
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
/* Find the nearest frequency at which data exists. */
index = oskar_find_closest_match_d(frequency_hz / 1.0e9,
sizeof(freqs_ghz) / sizeof(double), freqs_ghz);
f = frequency_hz / 1.0e9;
p1 = p1s[index];
p2 = p2s[index];
p3 = p3s[index];
/* Switch on precision. */
if (precision == OSKAR_SINGLE)
{
const float *l_, *m_;
l_ = oskar_mem_float_const(l, status);
m_ = oskar_mem_float_const(m, status);
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
if (type == OSKAR_SINGLE)
{
oskar_evaluate_vla_beam_pbcor_cuda_f(
oskar_mem_float(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
else if (type == OSKAR_SINGLE_COMPLEX)
{
oskar_evaluate_vla_beam_pbcor_complex_cuda_f(
oskar_mem_float2(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
else if (type == OSKAR_SINGLE_COMPLEX_MATRIX)
{
oskar_evaluate_vla_beam_pbcor_matrix_cuda_f(
oskar_mem_float4c(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
if (type == OSKAR_SINGLE)
{
oskar_evaluate_vla_beam_pbcor_f(
oskar_mem_float(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
else if (type == OSKAR_SINGLE_COMPLEX)
{
oskar_evaluate_vla_beam_pbcor_complex_f(
oskar_mem_float2(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
else if (type == OSKAR_SINGLE_COMPLEX_MATRIX)
{
oskar_evaluate_vla_beam_pbcor_matrix_f(
oskar_mem_float4c(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
}
}
else if (precision == OSKAR_DOUBLE)
{
const double *l_, *m_;
l_ = oskar_mem_double_const(l, status);
m_ = oskar_mem_double_const(m, status);
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
if (type == OSKAR_DOUBLE)
{
oskar_evaluate_vla_beam_pbcor_cuda_d(
oskar_mem_double(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
else if (type == OSKAR_DOUBLE_COMPLEX)
{
oskar_evaluate_vla_beam_pbcor_complex_cuda_d(
oskar_mem_double2(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
else if (type == OSKAR_DOUBLE_COMPLEX_MATRIX)
{
oskar_evaluate_vla_beam_pbcor_matrix_cuda_d(
oskar_mem_double4c(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
if (type == OSKAR_DOUBLE)
{
oskar_evaluate_vla_beam_pbcor_d(
oskar_mem_double(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
else if (type == OSKAR_DOUBLE_COMPLEX)
{
oskar_evaluate_vla_beam_pbcor_complex_d(
oskar_mem_double2(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
else if (type == OSKAR_DOUBLE_COMPLEX_MATRIX)
{
oskar_evaluate_vla_beam_pbcor_matrix_d(
oskar_mem_double4c(beam, status),
num_sources, l_, m_, f, p1, p2, p3);
}
}
}
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
}
void oskar_evaluate_station_beam_gaussian(oskar_Mem* beam,
int num_points, const oskar_Mem* l, const oskar_Mem* m,
const oskar_Mem* horizon_mask, double fwhm_rad, int* status)
{
int type, location;
double fwhm_lm, std;
/* Check if safe to proceed. */
if (*status) return;
/* Get type and check consistency. */
type = oskar_mem_precision(beam);
if (type != oskar_mem_type(l) || type != oskar_mem_type(m))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if (type != OSKAR_SINGLE && type != OSKAR_DOUBLE)
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
if (!oskar_mem_is_complex(beam))
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
if (fwhm_rad == 0.0)
{
*status = OSKAR_ERR_SETTINGS_TELESCOPE;
return;
}
/* Get location and check consistency. */
location = oskar_mem_location(beam);
if (location != oskar_mem_location(l) ||
location != oskar_mem_location(m))
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
/* Check that length of input arrays are consistent. */
if ((int)oskar_mem_length(l) < num_points ||
(int)oskar_mem_length(m) < num_points)
{
*status = OSKAR_ERR_DIMENSION_MISMATCH;
return;
}
/* Resize output array if needed. */
if ((int)oskar_mem_length(beam) < num_points)
oskar_mem_realloc(beam, num_points, status);
/* Check if safe to proceed. */
if (*status) return;
/* Compute Gaussian standard deviation from FWHM. */
fwhm_lm = sin(fwhm_rad);
std = fwhm_lm / (2.0 * sqrt(2.0 * log(2.0)));
if (type == OSKAR_DOUBLE)
{
const double *l_, *m_;
l_ = oskar_mem_double_const(l, status);
m_ = oskar_mem_double_const(m, status);
if (location == OSKAR_CPU)
{
if (oskar_mem_is_scalar(beam))
{
oskar_gaussian_d(oskar_mem_double2(beam, status),
num_points, l_, m_, std);
}
else
{
oskar_gaussian_md(oskar_mem_double4c(beam, status),
num_points, l_, m_, std);
}
}
else
{
#ifdef OSKAR_HAVE_CUDA
if (oskar_mem_is_scalar(beam))
{
oskar_gaussian_cuda_d(oskar_mem_double2(beam, status),
num_points, l_, m_, std);
}
else
{
oskar_gaussian_cuda_md(oskar_mem_double4c(beam, status),
num_points, l_, m_, std);
}
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
}
else /* type == OSKAR_SINGLE */
{
const float *l_, *m_;
l_ = oskar_mem_float_const(l, status);
m_ = oskar_mem_float_const(m, status);
if (location == OSKAR_CPU)
{
if (oskar_mem_is_scalar(beam))
{
oskar_gaussian_f(oskar_mem_float2(beam, status), num_points,
l_, m_, (float)std);
}
else
{
oskar_gaussian_mf(oskar_mem_float4c(beam, status), num_points,
l_, m_, (float)std);
}
}
else
{
#ifdef OSKAR_HAVE_CUDA
if (oskar_mem_is_scalar(beam))
{
oskar_gaussian_cuda_f(oskar_mem_float2(beam, status),
num_points, l_, m_, (float)std);
}
else
{
oskar_gaussian_cuda_mf(oskar_mem_float4c(beam, status),
num_points, l_, m_, (float)std);
}
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
}
/* Blank (zero) sources below the horizon. */
oskar_blank_below_horizon(beam, horizon_mask, num_points, status);
}
/* Wrapper. */
void oskar_evaluate_cross_power(int num_sources,
int num_stations, const oskar_Mem* jones, oskar_Mem* out,
int *status)
{
int type, location;
/* Check if safe to proceed. */
if (*status) return;
/* Check type and location. */
type = oskar_mem_type(jones);
location = oskar_mem_location(jones);
if (type != oskar_mem_type(out))
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
if (location != oskar_mem_location(out))
{
*status = OSKAR_ERR_LOCATION_MISMATCH;
return;
}
/* Switch on type and location combination. */
if (type == OSKAR_SINGLE_COMPLEX_MATRIX)
{
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_evaluate_cross_power_cuda_f(num_sources,
num_stations, oskar_mem_float4c_const(jones, status),
oskar_mem_float4c(out, status));
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
oskar_evaluate_cross_power_omp_f(num_sources,
num_stations, oskar_mem_float4c_const(jones, status),
oskar_mem_float4c(out, status));
}
}
else if (type == OSKAR_DOUBLE_COMPLEX_MATRIX)
{
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_evaluate_cross_power_cuda_d(num_sources,
num_stations, oskar_mem_double4c_const(jones, status),
oskar_mem_double4c(out, status));
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
oskar_evaluate_cross_power_omp_d(num_sources,
num_stations, oskar_mem_double4c_const(jones, status),
oskar_mem_double4c(out, status));
}
}
/* Scalar versions. */
else if (type == OSKAR_SINGLE_COMPLEX)
{
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_evaluate_cross_power_scalar_cuda_f(num_sources,
num_stations, oskar_mem_float2_const(jones, status),
oskar_mem_float2(out, status));
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
oskar_evaluate_cross_power_scalar_omp_f(num_sources,
num_stations, oskar_mem_float2_const(jones, status),
oskar_mem_float2(out, status));
}
}
else if (type == OSKAR_DOUBLE_COMPLEX)
{
if (location == OSKAR_GPU)
{
#ifdef OSKAR_HAVE_CUDA
oskar_evaluate_cross_power_scalar_cuda_d(num_sources,
num_stations, oskar_mem_double2_const(jones, status),
oskar_mem_double2(out, status));
oskar_device_check_error(status);
#else
*status = OSKAR_ERR_CUDA_NOT_AVAILABLE;
#endif
}
else if (location == OSKAR_CPU)
{
oskar_evaluate_cross_power_scalar_omp_d(num_sources,
num_stations, oskar_mem_double2_const(jones, status),
oskar_mem_double2(out, status));
}
}
else
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
}
}
