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_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); }
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_element_load_cst(oskar_Element* data, oskar_Log* log, int port, 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; size_t fname_len; oskar_Splines *data_h_re = 0, *data_h_im = 0; oskar_Splines *data_v_re = 0, *data_v_im = 0; oskar_Mem *theta, *phi, *h_re, *h_im, *v_re, *v_im, *weight; /* Declare the line buffer. */ char *line = 0, *dbi = 0, *ludwig3 = 0; size_t bufsize = 0; FILE* file; /* Check if safe to proceed. */ if (*status) return; /* Check port number. */ if (port != 0 && port != 1 && port != 2) { *status = OSKAR_ERR_INVALID_ARGUMENT; 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 port number and frequency index. */ if (port == 1 || port == 0) { data_h_re = oskar_element_x_h_re(data, i); data_h_im = oskar_element_x_h_im(data, i); data_v_re = oskar_element_x_v_re(data, i); data_v_im = oskar_element_x_v_im(data, i); } else if (port == 2) { data_h_re = oskar_element_y_h_re(data, i); data_h_im = oskar_element_y_h_im(data, i); data_v_re = oskar_element_y_v_re(data, i); data_v_im = oskar_element_y_v_im(data, i); } /* Open the file. */ fname_len = 1 + strlen(filename); file = fopen(filename, "r"); if (!file) { *status = OSKAR_ERR_FILE_IO; return; } /* Read the first line to check units and coordinate system. */ if (oskar_getline(&line, &bufsize, file) < 0) { *status = OSKAR_ERR_FILE_IO; free(line); fclose(file); return; } /* Check for presence of "dBi". */ dbi = strstr(line, "dBi"); /* Check for data in Ludwig-3 polarisation system. */ ludwig3 = strstr(line, "Horiz"); /* 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); h_re = oskar_mem_create(type, OSKAR_CPU, 0, status); h_im = oskar_mem_create(type, OSKAR_CPU, 0, status); v_re = oskar_mem_create(type, OSKAR_CPU, 0, status); v_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 t = 0., p = 0., abs_theta_horiz, phase_theta_horiz; double abs_phi_verti, phase_phi_verti; double theta_horiz_re, theta_horiz_im, phi_verti_re, phi_verti_im; double h_re_, h_im_, v_re_, v_im_; void *p_theta = 0, *p_phi = 0, *p_h_re = 0, *p_h_im = 0, *p_v_re = 0; void *p_v_im = 0, *p_weight = 0; /* Parse the line, and skip if data were not read correctly. */ if (sscanf(line, "%lf %lf %*f %lf %lf %lf %lf %*f", &t, &p, &abs_theta_horiz, &phase_theta_horiz, &abs_phi_verti, &phase_phi_verti) != 6) continue; /* Ignore data below horizon if requested. */ if (ignore_below_horizon && t > 90.0) continue; /* Ignore data at poles if requested. */ if (ignore_at_poles) if (t < 1e-6 || t > (180.0 - 1e-6)) continue; /* Convert angular measures to radians. */ t *= DEG2RAD; p *= DEG2RAD; phase_theta_horiz *= DEG2RAD; phase_phi_verti *= DEG2RAD; /* Ensure enough space in arrays. */ if (n % 100 == 0) { int size; size = n + 100; oskar_mem_realloc(theta, size, status); oskar_mem_realloc(phi, size, status); oskar_mem_realloc(h_re, size, status); oskar_mem_realloc(h_im, size, status); oskar_mem_realloc(v_re, size, status); oskar_mem_realloc(v_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_h_re = oskar_mem_void(h_re); p_h_im = oskar_mem_void(h_im); p_v_re = oskar_mem_void(v_re); p_v_im = oskar_mem_void(v_im); p_weight = oskar_mem_void(weight); /* Convert decibel to linear scale if necessary. */ if (dbi) { abs_theta_horiz = pow(10.0, abs_theta_horiz / 10.0); abs_phi_verti = pow(10.0, abs_phi_verti / 10.0); } /* Amp,phase to real,imag conversion. */ theta_horiz_re = abs_theta_horiz * cos(phase_theta_horiz); theta_horiz_im = abs_theta_horiz * sin(phase_theta_horiz); phi_verti_re = abs_phi_verti * cos(phase_phi_verti); phi_verti_im = abs_phi_verti * sin(phase_phi_verti); /* Convert to Ludwig-3 polarisation system if required. */ if (ludwig3) { /* Already in Ludwig-3: No conversion required. */ h_re_ = theta_horiz_re; h_im_ = theta_horiz_im; v_re_ = phi_verti_re; v_im_ = phi_verti_im; } else { /* Convert from theta/phi to Ludwig-3. */ double cos_p, sin_p; sin_p = sin(p); cos_p = cos(p); h_re_ = theta_horiz_re * cos_p - phi_verti_re * sin_p; h_im_ = theta_horiz_im * cos_p - phi_verti_im * sin_p; v_re_ = theta_horiz_re * sin_p + phi_verti_re * cos_p; v_im_ = theta_horiz_im * sin_p + phi_verti_im * cos_p; } /* Store the surface data in Ludwig-3 format. */ ((double*)p_theta)[n] = t; ((double*)p_phi)[n] = p; ((double*)p_h_re)[n] = h_re_; ((double*)p_h_im)[n] = h_im_; ((double*)p_v_re)[n] = v_re_; ((double*)p_v_im)[n] = v_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(log, data_h_re, n, theta, phi, h_re, weight, closeness, closeness_inc, "H [real]", status); fit_splines(log, data_h_im, n, theta, phi, h_im, weight, closeness, closeness_inc, "H [imag]", status); fit_splines(log, data_v_re, n, theta, phi, v_re, weight, closeness, closeness_inc, "V [real]", status); fit_splines(log, data_v_im, n, theta, phi, v_im, weight, closeness, closeness_inc, "V [imag]", status); /* Store the filename. */ if (port == 0) { oskar_mem_append_raw(data->filename_x[i], filename, OSKAR_CHAR, OSKAR_CPU, fname_len, status); oskar_mem_append_raw(data->filename_y[i], filename, OSKAR_CHAR, OSKAR_CPU, fname_len, status); } else if (port == 1) { oskar_mem_append_raw(data->filename_x[i], filename, OSKAR_CHAR, OSKAR_CPU, fname_len, status); } else if (port == 2) { oskar_mem_append_raw(data->filename_y[i], filename, OSKAR_CHAR, OSKAR_CPU, fname_len, status); } /* Copy X to Y if both ports are the same. */ if (port == 0) { oskar_splines_copy(data->y_h_re[i], data->x_h_re[i], status); oskar_splines_copy(data->y_h_im[i], data->x_h_im[i], status); oskar_splines_copy(data->y_v_re[i], data->x_v_re[i], status); oskar_splines_copy(data->y_v_im[i], data->x_v_im[i], status); } /* Free local arrays. */ oskar_mem_free(theta, status); oskar_mem_free(phi, status); oskar_mem_free(h_re, status); oskar_mem_free(h_im, status); oskar_mem_free(v_re, status); oskar_mem_free(v_im, status); oskar_mem_free(weight, status); }