oskar_Sky* oskar_sky_load(const char* filename, int type, int* status)
{
int n = 0;
FILE* file;
char* line = 0;
size_t bufsize = 0;
oskar_Sky* sky;
/* Check if safe to proceed. */
if (*status) return 0;
/* Get the data type. */
if (type != OSKAR_SINGLE && type != OSKAR_DOUBLE)
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return 0;
}
/* Open the file. */
file = fopen(filename, "r");
if (!file)
{
*status = OSKAR_ERR_FILE_IO;
return 0;
}
/* Initialise the sky model. */
sky = oskar_sky_create(type, OSKAR_CPU, 0, status);
/* Loop over lines in file. */
while (oskar_getline(&line, &bufsize, file) != OSKAR_ERR_EOF)
{
/* Set defaults. */
/* RA, Dec, I, Q, U, V, freq0, spix, RM, FWHM maj, FWHM min, PA */
double par[] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};
size_t num_param = sizeof(par) / sizeof(double);
size_t num_required = 3, num_read = 0;
/* Load source parameters (require at least RA, Dec, Stokes I). */
num_read = oskar_string_to_array_d(line, num_param, par);
if (num_read < num_required)
continue;
/* Ensure enough space in arrays. */
if (oskar_sky_num_sources(sky) <= n)
{
oskar_sky_resize(sky, n + 100, status);
if (*status)
break;
}
if (num_read <= 9)
{
/* RA, Dec, I, Q, U, V, freq0, spix, RM */
oskar_sky_set_source(sky, n, par[0] * deg2rad,
par[1] * deg2rad, par[2], par[3], par[4], par[5],
par[6], par[7], par[8], 0.0, 0.0, 0.0, status);
}
else if (num_read == 11)
{
/* Old format, with no rotation measure. */
/* RA, Dec, I, Q, U, V, freq0, spix, FWHM maj, FWHM min, PA */
oskar_sky_set_source(sky, n, par[0] * deg2rad,
par[1] * deg2rad, par[2], par[3], par[4], par[5],
par[6], par[7], 0.0, par[8] * arcsec2rad,
par[9] * arcsec2rad, par[10] * deg2rad, status);
}
else if (num_read == 12)
{
/* New format. */
/* RA, Dec, I, Q, U, V, freq0, spix, RM, FWHM maj, FWHM min, PA */
oskar_sky_set_source(sky, n, par[0] * deg2rad,
par[1] * deg2rad, par[2], par[3], par[4], par[5],
par[6], par[7], par[8], par[9] * arcsec2rad,
par[10] * arcsec2rad, par[11] * deg2rad, status);
}
else
{
/* Error. */
*status = OSKAR_ERR_BAD_SKY_FILE;
break;
}
++n;
}
/* Set the size to be the actual number of elements loaded. */
oskar_sky_resize(sky, n, status);
/* Free the line buffer and close the file. */
if (line) free(line);
fclose(file);
/* Check if an error occurred. */
if (*status)
{
oskar_sky_free(sky, status);
sky = 0;
}
/* Return a handle to the sky model. */
return sky;
}
void oskar_element_load_scalar(oskar_Element* data,
double freq_hz, const char* filename,
double closeness, double closeness_inc, int ignore_at_poles,
int ignore_below_horizon, int* status)
{
int i, n = 0, type = OSKAR_DOUBLE;
oskar_Splines *scalar_re = 0, *scalar_im = 0;
oskar_Mem *theta = 0, *phi = 0, *re = 0, *im = 0, *weight = 0;
/* Declare the line buffer. */
char *line = NULL;
size_t bufsize = 0;
FILE* file;
/* Check if safe to proceed. */
if (*status) return;
/* Check the data type. */
if (oskar_element_precision(data) != type)
{
*status = OSKAR_ERR_TYPE_MISMATCH;
return;
}
/* Check the location. */
if (oskar_element_mem_location(data) != OSKAR_CPU)
{
*status = OSKAR_ERR_BAD_LOCATION;
return;
}
/* Check if this frequency has already been set, and get its index if so. */
n = data->num_freq;
for (i = 0; i < n; ++i)
{
if (fabs(data->freqs_hz[i] - freq_hz) <= freq_hz * DBL_EPSILON)
break;
}
/* Expand arrays to hold data for a new frequency, if needed. */
if (i >= data->num_freq)
{
i = data->num_freq;
oskar_element_resize_freq_data(data, i + 1, status);
data->freqs_hz[i] = freq_hz;
}
/* Get pointers to surface data based on frequency index. */
scalar_re = data->scalar_re[i];
scalar_im = data->scalar_im[i];
/* Open the file. */
file = fopen(filename, "r");
if (!file)
{
*status = OSKAR_ERR_FILE_IO;
return;
}
/* Create local arrays to hold data for fitting. */
theta = oskar_mem_create(type, OSKAR_CPU, 0, status);
phi = oskar_mem_create(type, OSKAR_CPU, 0, status);
re = oskar_mem_create(type, OSKAR_CPU, 0, status);
im = oskar_mem_create(type, OSKAR_CPU, 0, status);
weight = oskar_mem_create(type, OSKAR_CPU, 0, status);
if (*status) return;
/* Loop over and read each line in the file. */
n = 0;
while (oskar_getline(&line, &bufsize, file) != OSKAR_ERR_EOF)
{
double re_, im_;
double par[] = {0., 0., 0., 0.}; /* theta, phi, amp, phase (optional) */
void *p_theta = 0, *p_phi = 0, *p_re = 0, *p_im = 0, *p_weight = 0;
/* Parse the line, and skip if data were not read correctly. */
if (oskar_string_to_array_d(line, 4, par) < 3)
continue;
/* Ignore data below horizon if requested. */
if (ignore_below_horizon && par[0] > 90.0) continue;
/* Ignore data at poles if requested. */
if (ignore_at_poles)
if (par[0] < 1e-6 || par[0] > (180.0 - 1e-6)) continue;
/* Convert angular measures to radians. */
par[0] *= DEG2RAD; /* theta */
par[1] *= DEG2RAD; /* phi */
par[3] *= DEG2RAD; /* phase */
/* Ensure enough space in arrays. */
if (n % 100 == 0)
{
const int size = n + 100;
oskar_mem_realloc(theta, size, status);
oskar_mem_realloc(phi, size, status);
oskar_mem_realloc(re, size, status);
oskar_mem_realloc(im, size, status);
oskar_mem_realloc(weight, size, status);
if (*status) break;
}
p_theta = oskar_mem_void(theta);
p_phi = oskar_mem_void(phi);
p_re = oskar_mem_void(re);
p_im = oskar_mem_void(im);
p_weight = oskar_mem_void(weight);
/* Amp,phase to real,imag conversion. */
re_ = par[2] * cos(par[3]);
im_ = par[2] * sin(par[3]);
/* Store the surface data. */
((double*)p_theta)[n] = par[0];
((double*)p_phi)[n] = par[1];
((double*)p_re)[n] = re_;
((double*)p_im)[n] = im_;
((double*)p_weight)[n] = 1.0;
/* Increment array pointer. */
n++;
}
/* Free the line buffer and close the file. */
free(line);
fclose(file);
/* Fit splines to the surface data. */
fit_splines(scalar_re, n, theta, phi, re, weight,
closeness, closeness_inc, "Scalar [real]", status);
fit_splines(scalar_im, n, theta, phi, im, weight,
closeness, closeness_inc, "Scalar [imag]", status);
/* Store the filename. */
oskar_mem_append_raw(data->filename_scalar[i], filename, OSKAR_CHAR,
OSKAR_CPU, 1 + strlen(filename), status);
/* Free local arrays. */
oskar_mem_free(theta, status);
oskar_mem_free(phi, status);
oskar_mem_free(re, status);
oskar_mem_free(im, status);
oskar_mem_free(weight, status);
}
void oskar_station_load_layout(oskar_Station* station, const char* filename,
int* status)
{
/* Declare the line buffer and counter. */
char* line = NULL;
size_t bufsize = 0;
int n = 0, type = 0, old_size = 0;
FILE* file;
/* Check if safe to proceed. */
if (*status) return;
/* Check type. */
type = oskar_station_precision(station);
if (type != OSKAR_SINGLE && type != OSKAR_DOUBLE)
{
*status = OSKAR_ERR_BAD_DATA_TYPE;
return;
}
/* Open the file. */
file = fopen(filename, "r");
if (!file)
{
*status = OSKAR_ERR_FILE_IO;
return;
}
/* Get the size of the station before loading the data. */
old_size = oskar_station_num_elements(station);
/* Loop over each line in the file. */
while (oskar_getline(&line, &bufsize, file) != OSKAR_ERR_EOF)
{
/* Declare parameter array. */
/* x, y, z, delta x, delta y, delta z */
double par[] = {0., 0., 0., 0., 0., 0.};
size_t num_par = sizeof(par) / sizeof(double);
/* Load element data. */
if (oskar_string_to_array_d(line, num_par, par) < 2) continue;
/* Ensure the station model is big enough. */
if (oskar_station_num_elements(station) <= n)
{
oskar_station_resize(station, n + 100, status);
if (*status) break;
}
/* Get "true" coordinates ([3, 4, 5]) from "measured" coordinates. */
par[3] += par[0];
par[4] += par[1];
par[5] += par[2];
/* Store the data. */
oskar_station_set_element_coords(station, n, &par[0], &par[3], status);
/* Increment element counter. */
++n;
}
/* Record number of elements loaded, if the station wasn't sized before. */
if (old_size == 0)
{
oskar_station_resize(station, n, status);
}
else
{
/* Consistency check. */
if (n != old_size)
*status = OSKAR_ERR_DIMENSION_MISMATCH;
}
/* Free the line buffer and close the file. */
if (line) free(line);
fclose(file);
}
static void load_coords(oskar_Mem* lon, oskar_Mem* lat,
const char* filename, int* status)
{
int type = 0;
FILE* file;
char* line = 0;
size_t n = 0, bufsize = 0;
if (*status) return;
/* Set initial size of coordinate arrays. */
type = oskar_mem_precision(lon);
oskar_mem_realloc(lon, 100, status);
oskar_mem_realloc(lat, 100, status);
/* Open the file. */
file = fopen(filename, "r");
if (!file)
{
*status = OSKAR_ERR_FILE_IO;
return;
}
/* Loop over lines in file. */
while (oskar_getline(&line, &bufsize, file) != OSKAR_ERR_EOF)
{
/* Set defaults. */
/* Longitude, latitude. */
double par[] = {0., 0.};
size_t num_param = sizeof(par) / sizeof(double);
size_t num_required = 2, num_read = 0;
/* Load coordinates. */
num_read = oskar_string_to_array_d(line, num_param, par);
if (num_read < num_required) continue;
/* Ensure enough space in arrays. */
if (oskar_mem_length(lon) <= n)
{
oskar_mem_realloc(lon, n + 100, status);
oskar_mem_realloc(lat, n + 100, status);
if (*status) break;
}
/* Store the coordinates. */
if (type == OSKAR_DOUBLE)
{
oskar_mem_double(lon, status)[n] = par[0] * M_PI/180.0;
oskar_mem_double(lat, status)[n] = par[1] * M_PI/180.0;
}
else
{
oskar_mem_float(lon, status)[n] = par[0] * M_PI/180.0;
oskar_mem_float(lat, status)[n] = par[1] * M_PI/180.0;
}
++n;
}
/* Resize output arrays to final size. */
oskar_mem_realloc(lon, n, status);
oskar_mem_realloc(lat, n, status);
fclose(file);
free(line);
}
