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;
}
static PyObject* append_sources(PyObject* self, PyObject* args)
{
oskar_Sky *h = 0;
PyObject *obj[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
oskar_Mem *ra_c, *dec_c, *I_c, *Q_c, *U_c, *V_c;
oskar_Mem *ref_c, *spix_c, *rm_c, *maj_c, *min_c, *pa_c;
PyArrayObject *ra = 0, *dec = 0, *I = 0, *Q = 0, *U = 0, *V = 0;
PyArrayObject *ref = 0, *spix = 0, *rm = 0, *maj = 0, *min = 0, *pa = 0;
int status = 0, npy_type, type, flags, num_sources, old_num;
/* Parse inputs: RA, Dec, I, Q, U, V, ref, spix, rm, maj, min, pa. */
if (!PyArg_ParseTuple(args, "OOOOOOOOOOOOO", &obj[0],
&obj[1], &obj[2], &obj[3], &obj[4], &obj[5], &obj[6],
&obj[7], &obj[8], &obj[9], &obj[10], &obj[11], &obj[12]))
return 0;
if (!(h = get_handle(obj[0]))) return 0;
/* Make sure input objects are arrays. Convert if required. */
flags = NPY_ARRAY_FORCECAST | NPY_ARRAY_IN_ARRAY;
type = oskar_sky_precision(h);
npy_type = numpy_type_from_oskar(type);
ra = (PyArrayObject*) PyArray_FROM_OTF(obj[1], npy_type, flags);
dec = (PyArrayObject*) PyArray_FROM_OTF(obj[2], npy_type, flags);
I = (PyArrayObject*) PyArray_FROM_OTF(obj[3], npy_type, flags);
Q = (PyArrayObject*) PyArray_FROM_OTF(obj[4], npy_type, flags);
U = (PyArrayObject*) PyArray_FROM_OTF(obj[5], npy_type, flags);
V = (PyArrayObject*) PyArray_FROM_OTF(obj[6], npy_type, flags);
ref = (PyArrayObject*) PyArray_FROM_OTF(obj[7], npy_type, flags);
spix = (PyArrayObject*) PyArray_FROM_OTF(obj[8], npy_type, flags);
rm = (PyArrayObject*) PyArray_FROM_OTF(obj[9], npy_type, flags);
maj = (PyArrayObject*) PyArray_FROM_OTF(obj[10], npy_type, flags);
min = (PyArrayObject*) PyArray_FROM_OTF(obj[11], npy_type, flags);
pa = (PyArrayObject*) PyArray_FROM_OTF(obj[12], npy_type, flags);
if (!ra || !dec || !I || !Q || !U || !V ||
!ref || !spix || !rm || !maj || !min || !pa)
goto fail;
/* Check size of input arrays. */
num_sources = (int) PyArray_SIZE(I);
if (num_sources != (int) PyArray_SIZE(ra) ||
num_sources != (int) PyArray_SIZE(dec) ||
num_sources != (int) PyArray_SIZE(Q) ||
num_sources != (int) PyArray_SIZE(U) ||
num_sources != (int) PyArray_SIZE(V) ||
num_sources != (int) PyArray_SIZE(ref) ||
num_sources != (int) PyArray_SIZE(spix) ||
num_sources != (int) PyArray_SIZE(rm) ||
num_sources != (int) PyArray_SIZE(maj) ||
num_sources != (int) PyArray_SIZE(min) ||
num_sources != (int) PyArray_SIZE(pa))
{
PyErr_SetString(PyExc_RuntimeError, "Input data dimension mismatch.");
goto fail;
}
/* Pointers to input arrays. */
ra_c = oskar_mem_create_alias_from_raw(PyArray_DATA(ra),
type, OSKAR_CPU, num_sources, &status);
dec_c = oskar_mem_create_alias_from_raw(PyArray_DATA(dec),
type, OSKAR_CPU, num_sources, &status);
I_c = oskar_mem_create_alias_from_raw(PyArray_DATA(I),
type, OSKAR_CPU, num_sources, &status);
Q_c = oskar_mem_create_alias_from_raw(PyArray_DATA(Q),
type, OSKAR_CPU, num_sources, &status);
U_c = oskar_mem_create_alias_from_raw(PyArray_DATA(U),
type, OSKAR_CPU, num_sources, &status);
V_c = oskar_mem_create_alias_from_raw(PyArray_DATA(V),
type, OSKAR_CPU, num_sources, &status);
ref_c = oskar_mem_create_alias_from_raw(PyArray_DATA(ref),
type, OSKAR_CPU, num_sources, &status);
spix_c = oskar_mem_create_alias_from_raw(PyArray_DATA(spix),
type, OSKAR_CPU, num_sources, &status);
rm_c = oskar_mem_create_alias_from_raw(PyArray_DATA(rm),
type, OSKAR_CPU, num_sources, &status);
maj_c = oskar_mem_create_alias_from_raw(PyArray_DATA(maj),
type, OSKAR_CPU, num_sources, &status);
min_c = oskar_mem_create_alias_from_raw(PyArray_DATA(min),
type, OSKAR_CPU, num_sources, &status);
pa_c = oskar_mem_create_alias_from_raw(PyArray_DATA(pa),
type, OSKAR_CPU, num_sources, &status);
/* Copy source data into the sky model. */
old_num = oskar_sky_num_sources(h);
oskar_sky_resize(h, old_num + num_sources, &status);
oskar_mem_copy_contents(oskar_sky_ra_rad(h), ra_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_dec_rad(h), dec_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_I(h), I_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_Q(h), Q_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_U(h), U_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_V(h), V_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_reference_freq_hz(h), ref_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_spectral_index(h), spix_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_rotation_measure_rad(h), rm_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_fwhm_major_rad(h), maj_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_fwhm_minor_rad(h), min_c,
old_num, 0, num_sources, &status);
oskar_mem_copy_contents(oskar_sky_position_angle_rad(h), pa_c,
old_num, 0, num_sources, &status);
/* Free memory. */
oskar_mem_free(ra_c, &status);
oskar_mem_free(dec_c, &status);
oskar_mem_free(I_c, &status);
oskar_mem_free(Q_c, &status);
oskar_mem_free(U_c, &status);
oskar_mem_free(V_c, &status);
oskar_mem_free(ref_c, &status);
oskar_mem_free(spix_c, &status);
oskar_mem_free(rm_c, &status);
oskar_mem_free(maj_c, &status);
oskar_mem_free(min_c, &status);
oskar_mem_free(pa_c, &status);
/* Check for errors. */
if (status)
{
PyErr_Format(PyExc_RuntimeError,
"Sky model append_sources() failed with code %d (%s).",
status, oskar_get_error_string(status));
goto fail;
}
Py_XDECREF(ra);
Py_XDECREF(dec);
Py_XDECREF(I);
Py_XDECREF(Q);
Py_XDECREF(U);
Py_XDECREF(V);
Py_XDECREF(ref);
Py_XDECREF(spix);
Py_XDECREF(rm);
Py_XDECREF(maj);
Py_XDECREF(min);
Py_XDECREF(pa);
return Py_BuildValue("");
fail:
Py_XDECREF(ra);
Py_XDECREF(dec);
Py_XDECREF(I);
Py_XDECREF(Q);
Py_XDECREF(U);
Py_XDECREF(V);
Py_XDECREF(ref);
Py_XDECREF(spix);
Py_XDECREF(rm);
Py_XDECREF(maj);
Py_XDECREF(min);
Py_XDECREF(pa);
return 0;
}
