void oskar_station_create_child_stations(oskar_Station* station,
int* status)
{
int i, type, location;
/* Check if safe to proceed. */
if (*status) return;
/* Check that the memory isn't already allocated. */
if (station->child)
{
*status = OSKAR_ERR_MEMORY_ALLOC_FAILURE;
return;
}
/* Allocate memory for child station array. */
station->child = (oskar_Station**) malloc(
station->num_elements * sizeof(oskar_Station*));
if (!station->child)
{
*status = OSKAR_ERR_MEMORY_ALLOC_FAILURE;
return;
}
/* Create and initialise each child station. */
type = oskar_station_precision(station);
location = oskar_station_mem_location(station);
for (i = 0; i < station->num_elements; ++i)
{
station->child[i] = oskar_station_create(type, location, 0, status);
}
}
void oskar_station_resize_element_types(oskar_Station* model,
int num_element_types, int* status)
{
int i, old_num_element_types;
/* Check if safe to proceed. */
if (*status) return;
/* Get the old size. */
old_num_element_types = model->num_element_types;
/* Check if increasing or decreasing in size. */
if (num_element_types > old_num_element_types)
{
/* Enlarge the element array and create new elements. */
model->element = (oskar_Element**) realloc(model->element,
num_element_types * sizeof(oskar_Element*));
if (!model->element)
{
*status = OSKAR_ERR_MEMORY_ALLOC_FAILURE;
return;
}
for (i = old_num_element_types; i < num_element_types; ++i)
{
model->element[i] = oskar_element_create(
oskar_station_precision(model),
oskar_station_mem_location(model), status);
}
}
else if (num_element_types < old_num_element_types)
{
/* Free old elements and shrink the element array. */
for (i = num_element_types; i < old_num_element_types; ++i)
{
oskar_element_free(oskar_station_element(model, i), status);
}
model->element = (oskar_Element**) realloc(model->element,
num_element_types * sizeof(oskar_Element*));
}
/* Update the new size. */
model->num_element_types = num_element_types;
}
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);
}
oskar_Station* oskar_station_create_copy(const oskar_Station* src,
int location, int* status)
{
int i = 0;
oskar_Station* model = 0;
/* Check if safe to proceed. */
if (*status) return model;
/* Create the new model. */
model = oskar_station_create(oskar_station_precision(src), location,
oskar_station_num_elements(src), status);
/* Set meta-data. */
model->unique_id = src->unique_id;
model->precision = src->precision;
model->mem_location = location;
/* Copy common station parameters. */
model->station_type = src->station_type;
model->normalise_final_beam = src->normalise_final_beam;
model->lon_rad = src->lon_rad;
model->lat_rad = src->lat_rad;
model->alt_metres = src->alt_metres;
model->pm_x_rad = src->pm_x_rad;
model->pm_y_rad = src->pm_y_rad;
model->beam_lon_rad = src->beam_lon_rad;
model->beam_lat_rad = src->beam_lat_rad;
model->beam_coord_type = src->beam_coord_type;
oskar_mem_copy(model->noise_freq_hz, src->noise_freq_hz, status);
oskar_mem_copy(model->noise_rms_jy, src->noise_rms_jy, status);
/* Copy aperture array data, except num_element_types (done later). */
model->identical_children = src->identical_children;
model->num_elements = src->num_elements;
model->normalise_array_pattern = src->normalise_array_pattern;
model->enable_array_pattern = src->enable_array_pattern;
model->common_element_orientation = src->common_element_orientation;
model->array_is_3d = src->array_is_3d;
model->apply_element_errors = src->apply_element_errors;
model->apply_element_weight = src->apply_element_weight;
model->seed_time_variable_errors = src->seed_time_variable_errors;
model->num_permitted_beams = src->num_permitted_beams;
/* Copy Gaussian station beam data. */
model->gaussian_beam_fwhm_rad = src->gaussian_beam_fwhm_rad;
model->gaussian_beam_reference_freq_hz = src->gaussian_beam_reference_freq_hz;
/* Copy memory blocks. */
oskar_mem_copy(model->element_true_x_enu_metres,
src->element_true_x_enu_metres, status);
oskar_mem_copy(model->element_true_y_enu_metres,
src->element_true_y_enu_metres, status);
oskar_mem_copy(model->element_true_z_enu_metres,
src->element_true_z_enu_metres, status);
oskar_mem_copy(model->element_measured_x_enu_metres,
src->element_measured_x_enu_metres, status);
oskar_mem_copy(model->element_measured_y_enu_metres,
src->element_measured_y_enu_metres, status);
oskar_mem_copy(model->element_measured_z_enu_metres,
src->element_measured_z_enu_metres, status);
oskar_mem_copy(model->element_weight, src->element_weight, status);
oskar_mem_copy(model->element_gain, src->element_gain, status);
oskar_mem_copy(model->element_gain_error, src->element_gain_error, status);
oskar_mem_copy(model->element_phase_offset_rad,
src->element_phase_offset_rad, status);
oskar_mem_copy(model->element_phase_error_rad,
src->element_phase_error_rad, status);
oskar_mem_copy(model->element_x_alpha_cpu,
src->element_x_alpha_cpu, status);
oskar_mem_copy(model->element_x_beta_cpu,
src->element_x_beta_cpu, status);
oskar_mem_copy(model->element_x_gamma_cpu,
src->element_x_gamma_cpu, status);
oskar_mem_copy(model->element_y_alpha_cpu,
src->element_y_alpha_cpu, status);
oskar_mem_copy(model->element_y_beta_cpu,
src->element_y_beta_cpu, status);
oskar_mem_copy(model->element_y_gamma_cpu,
src->element_y_gamma_cpu, status);
oskar_mem_copy(model->element_types, src->element_types, status);
oskar_mem_copy(model->element_types_cpu, src->element_types_cpu, status);
oskar_mem_copy(model->element_mount_types_cpu, src->element_mount_types_cpu, status);
oskar_mem_copy(model->permitted_beam_az_rad, src->permitted_beam_az_rad, status);
oskar_mem_copy(model->permitted_beam_el_rad, src->permitted_beam_el_rad, status);
/* Copy element models, if set. */
if (oskar_station_has_element(src))
{
/* Ensure enough space for element model data. */
oskar_station_resize_element_types(model, src->num_element_types,
status);
/* Copy the element model data. */
for (i = 0; i < src->num_element_types; ++i)
{
oskar_element_copy(model->element[i], src->element[i], status);
}
}
/* Recursively copy child stations. */
if (oskar_station_has_child(src))
{
model->child = malloc(src->num_elements * sizeof(oskar_Station*));
if (!model->child)
{
*status = OSKAR_ERR_MEMORY_ALLOC_FAILURE;
return model;
}
for (i = 0; i < src->num_elements; ++i)
{
model->child[i] = oskar_station_create_copy(
oskar_station_child_const(src, i), location, status);
}
}
return model;
}
