static void oskar_telescope_set_station_type_p(oskar_Station* station, int type) { oskar_station_set_station_type(station, type); if (oskar_station_has_child(station)) { int i, num_elements; num_elements = oskar_station_num_elements(station); for (i = 0; i < num_elements; ++i) { oskar_telescope_set_station_type_p( oskar_station_child(station, i), type); } } }
void oskar_evaluate_element_weights(oskar_Mem* weights, oskar_Mem* weights_error, double wavenumber, const oskar_Station* station, double x_beam, double y_beam, double z_beam, int time_index, int* status) { int num_elements; /* Check if safe to proceed. */ if (*status) return; /* Resize weights and weights error work arrays if required. */ num_elements = oskar_station_num_elements(station); if ((int)oskar_mem_length(weights) < num_elements) oskar_mem_realloc(weights, num_elements, status); if ((int)oskar_mem_length(weights_error) < num_elements) oskar_mem_realloc(weights_error, num_elements, status); /* Generate DFT weights. */ oskar_evaluate_element_weights_dft(weights, num_elements, wavenumber, oskar_station_element_measured_x_enu_metres_const(station), oskar_station_element_measured_y_enu_metres_const(station), oskar_station_element_measured_z_enu_metres_const(station), x_beam, y_beam, z_beam, status); /* Apply time-variable errors. */ if (oskar_station_apply_element_errors(station)) { /* Generate weights errors. */ oskar_evaluate_element_weights_errors(num_elements, oskar_station_element_gain_const(station), oskar_station_element_gain_error_const(station), oskar_station_element_phase_offset_rad_const(station), oskar_station_element_phase_error_rad_const(station), oskar_station_seed_time_variable_errors(station), time_index, oskar_station_unique_id(station), weights_error, status); /* Modify the weights (complex multiply with error vector). */ oskar_mem_element_multiply(0, weights, weights_error, num_elements, status); } /* Modify the weights using the provided apodisation values. */ if (oskar_station_apply_element_weight(station)) { oskar_mem_element_multiply(0, weights, oskar_station_element_weight_const(station), num_elements, status); } }
static void oskar_telescope_set_gaussian_station_beam_p(oskar_Station* station, double fwhm_rad, double ref_freq_hz) { oskar_station_set_gaussian_beam_values(station, fwhm_rad, ref_freq_hz); if (oskar_station_has_child(station)) { int i, num_elements; num_elements = oskar_station_num_elements(station); for (i = 0; i < num_elements; ++i) { oskar_telescope_set_gaussian_station_beam_p( oskar_station_child(station, i), fwhm_rad, ref_freq_hz); } } }
static void max_station_size_and_depth(const oskar_Station* s, int* max_elements, int* max_depth, int depth) { int i, num_elements; num_elements = oskar_station_num_elements(s); *max_elements = num_elements > *max_elements ? num_elements : *max_elements; *max_depth = depth > *max_depth ? depth : *max_depth; if (oskar_station_has_child(s)) { for (i = 0; i < num_elements; ++i) { max_station_size_and_depth(oskar_station_child_const(s, i), max_elements, max_depth, depth + 1); } } }
static void oskar_telescope_set_station_phase_centre(oskar_Station* station, int coord_type, double ra_rad, double dec_rad) { oskar_station_set_phase_centre(station, coord_type, ra_rad, dec_rad); if (oskar_station_has_child(station)) { int i, num_elements; num_elements = oskar_station_num_elements(station); for (i = 0; i < num_elements; ++i) { oskar_telescope_set_station_phase_centre( oskar_station_child(station, i), coord_type, ra_rad, dec_rad); } } }
static void set_child_station_locations(oskar_Station* s, const oskar_Station* parent) { if (parent) { oskar_station_set_position(s, oskar_station_lon_rad(parent), oskar_station_lat_rad(parent), oskar_station_alt_metres(parent)); } /* Recursively set data for child stations. */ if (oskar_station_has_child(s)) { int i, num_elements; num_elements = oskar_station_num_elements(s); for (i = 0; i < num_elements; ++i) set_child_station_locations(oskar_station_child(s, i), s); } }
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; }
static void oskar_evaluate_station_beam_aperture_array_private(oskar_Mem* beam, const oskar_Station* s, int num_points, const oskar_Mem* x, const oskar_Mem* y, const oskar_Mem* z, double gast, double frequency_hz, oskar_StationWork* work, int time_index, int depth, int* status) { double beam_x, beam_y, beam_z, wavenumber; oskar_Mem *weights, *weights_error, *theta, *phi, *array; int num_elements, is_3d; num_elements = oskar_station_num_elements(s); is_3d = oskar_station_array_is_3d(s); weights = work->weights; weights_error = work->weights_error; theta = work->theta_modified; phi = work->phi_modified; array = work->array_pattern; wavenumber = 2.0 * M_PI * frequency_hz / 299792458.0; /* Check if safe to proceed. */ if (*status) return; /* Compute direction cosines for the beam for this station. */ oskar_evaluate_beam_horizon_direction(&beam_x, &beam_y, &beam_z, s, gast, status); /* Evaluate beam if there are no child stations. */ if (!oskar_station_has_child(s)) { /* First optimisation: A single element model type, and either a common * orientation for all elements within the station, or isotropic * elements. */ /* Array pattern and element pattern are separable. */ if (oskar_station_num_element_types(s) == 1 && (oskar_station_common_element_orientation(s) || oskar_element_type(oskar_station_element_const(s, 0)) == OSKAR_ELEMENT_TYPE_ISOTROPIC) ) { /* (Always) evaluate element pattern into the output beam array. */ oskar_element_evaluate(oskar_station_element_const(s, 0), beam, oskar_station_element_x_alpha_rad(s, 0) + M_PI/2.0, /* FIXME Will change: This matches the old convention. */ oskar_station_element_y_alpha_rad(s, 0), num_points, x, y, z, frequency_hz, theta, phi, status); /* Check if array pattern is enabled. */ if (oskar_station_enable_array_pattern(s)) { /* Generate beamforming weights and evaluate array pattern. */ oskar_evaluate_element_weights(weights, weights_error, wavenumber, s, beam_x, beam_y, beam_z, time_index, status); oskar_dftw(num_elements, wavenumber, oskar_station_element_true_x_enu_metres_const(s), oskar_station_element_true_y_enu_metres_const(s), oskar_station_element_true_z_enu_metres_const(s), weights, num_points, x, y, (is_3d ? z : 0), 0, array, status); /* Normalise array response if required. */ if (oskar_station_normalise_array_pattern(s)) oskar_mem_scale_real(array, 1.0 / num_elements, status); /* Element-wise multiply to join array and element pattern. */ oskar_mem_multiply(beam, beam, array, num_points, status); } } #if 0 /* Second optimisation: Common orientation for all elements within the * station, but more than one element type. */ else if (oskar_station_common_element_orientation(s)) { /* Must evaluate array pattern, so check that this is enabled. */ if (!oskar_station_enable_array_pattern(s)) { *status = OSKAR_ERR_SETTINGS_TELESCOPE; return; } /* Call a DFT using indexed input. */ /* TODO Not yet implemented. */ *status = OSKAR_ERR_FUNCTION_NOT_AVAILABLE; } #endif /* No optimisation: No common element orientation. */ /* Can't separate array and element evaluation. */ else { int i, num_element_types; oskar_Mem *element_block = 0, *element = 0; const int* element_type_array = 0; /* Must evaluate array pattern, so check that this is enabled. */ if (!oskar_station_enable_array_pattern(s)) { *status = OSKAR_ERR_SETTINGS_TELESCOPE; return; } /* Get sized element pattern block (at depth 0). */ element_block = oskar_station_work_beam(work, beam, num_elements * num_points, 0, status); /* Create alias into element block. */ element = oskar_mem_create_alias(element_block, 0, 0, status); /* Loop over elements and evaluate response for each. */ element_type_array = oskar_station_element_types_cpu_const(s); num_element_types = oskar_station_num_element_types(s); for (i = 0; i < num_elements; ++i) { int element_type_idx; element_type_idx = element_type_array[i]; if (element_type_idx >= num_element_types) { *status = OSKAR_ERR_OUT_OF_RANGE; break; } oskar_mem_set_alias(element, element_block, i * num_points, num_points, status); oskar_element_evaluate( oskar_station_element_const(s, element_type_idx), element, oskar_station_element_x_alpha_rad(s, i) + M_PI/2.0, /* FIXME Will change: This matches the old convention. */ oskar_station_element_y_alpha_rad(s, i), num_points, x, y, z, frequency_hz, theta, phi, status); } /* Generate beamforming weights. */ oskar_evaluate_element_weights(weights, weights_error, wavenumber, s, beam_x, beam_y, beam_z, time_index, status); /* Use DFT to evaluate array response. */ oskar_dftw(num_elements, wavenumber, oskar_station_element_true_x_enu_metres_const(s), oskar_station_element_true_y_enu_metres_const(s), oskar_station_element_true_z_enu_metres_const(s), weights, num_points, x, y, (is_3d ? z : 0), element_block, beam, status); /* Free element alias. */ oskar_mem_free(element, status); /* Normalise array response if required. */ if (oskar_station_normalise_array_pattern(s)) oskar_mem_scale_real(beam, 1.0 / num_elements, status); } /* Blank (set to zero) points below the horizon. */ oskar_blank_below_horizon(num_points, z, beam, status); } /* If there are child stations, must first evaluate the beam for each. */ else { int i; oskar_Mem* signal; /* Must evaluate array pattern, so check that this is enabled. */ if (!oskar_station_enable_array_pattern(s)) { *status = OSKAR_ERR_SETTINGS_TELESCOPE; return; } /* Get sized work array for this depth, with the correct type. */ signal = oskar_station_work_beam(work, beam, num_elements * num_points, depth, status); /* Check if child stations are identical. */ if (oskar_station_identical_children(s)) { /* Set up the output buffer for the first station. */ oskar_Mem* output0; output0 = oskar_mem_create_alias(signal, 0, num_points, status); /* Recursive call. */ oskar_evaluate_station_beam_aperture_array_private(output0, oskar_station_child_const(s, 0), num_points, x, y, z, gast, frequency_hz, work, time_index, depth + 1, status); /* Copy beam for child station 0 into memory for other stations. */ for (i = 1; i < num_elements; ++i) { oskar_mem_copy_contents(signal, output0, i * num_points, 0, oskar_mem_length(output0), status); } oskar_mem_free(output0, status); } else { /* Loop over child stations. */ for (i = 0; i < num_elements; ++i) { /* Set up the output buffer for this station. */ oskar_Mem* output; output = oskar_mem_create_alias(signal, i * num_points, num_points, status); /* Recursive call. */ oskar_evaluate_station_beam_aperture_array_private(output, oskar_station_child_const(s, i), num_points, x, y, z, gast, frequency_hz, work, time_index, depth + 1, status); oskar_mem_free(output, status); } } /* Generate beamforming weights and form beam from child stations. */ oskar_evaluate_element_weights(weights, weights_error, wavenumber, s, beam_x, beam_y, beam_z, time_index, status); oskar_dftw(num_elements, wavenumber, oskar_station_element_true_x_enu_metres_const(s), oskar_station_element_true_y_enu_metres_const(s), oskar_station_element_true_z_enu_metres_const(s), weights, num_points, x, y, (is_3d ? z : 0), signal, beam, status); /* Normalise array response if required. */ if (oskar_station_normalise_array_pattern(s)) oskar_mem_scale_real(beam, 1.0 / num_elements, status); } }