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; }