int main(int argc, char** argv)
{
int status = 0;
oskar::OptionParser opt("oskar_convert_geodetic_to_ecef",
oskar_version_string());
opt.set_description("Converts geodetic longitude/latitude/altitude to "
"Cartesian ECEF coordinates. Assumes WGS84 ellipsoid.");
opt.add_required("input file", "Path to file containing input coordinates. "
"Angles must be in degrees.");
if (!opt.check_options(argc, argv))
return OSKAR_FAIL;
const char* filename = opt.get_arg();
// Load the input file.
oskar_Mem *lon = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, &status);
oskar_Mem *lat = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, &status);
oskar_Mem *alt = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, &status);
size_t num_points = oskar_mem_load_ascii(filename, 3, &status,
lon, "", lat, "", alt, "0.0");
oskar_mem_scale_real(lon, M_PI / 180.0, &status);
oskar_mem_scale_real(lat, M_PI / 180.0, &status);
// Convert coordinates.
oskar_Mem *x = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_points, &status);
oskar_Mem *y = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_points, &status);
oskar_Mem *z = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_points, &status);
oskar_convert_geodetic_spherical_to_ecef(num_points,
oskar_mem_double_const(lon, &status),
oskar_mem_double_const(lat, &status),
oskar_mem_double_const(alt, &status),
oskar_mem_double(x, &status),
oskar_mem_double(y, &status),
oskar_mem_double(z, &status));
// Print converted coordinates.
oskar_mem_save_ascii(stdout, 3, num_points, &status, x, y, z);
// Clean up.
oskar_mem_free(lon, &status);
oskar_mem_free(lat, &status);
oskar_mem_free(alt, &status);
oskar_mem_free(x, &status);
oskar_mem_free(y, &status);
oskar_mem_free(z, &status);
if (status)
{
oskar_log_error(0, oskar_get_error_string(status));
return status;
}
return 0;
}
int main(int argc, char** argv)
{
int error = 0;
oskar::OptionParser opt("oskar_fits_image_to_sky_model",
oskar_version_string());
opt.set_description("Converts a FITS image to an OSKAR sky model. A number "
"of options are provided to control how much of the image is used "
"to make the sky model.");
opt.add_required("FITS file", "The input FITS image to convert.");
opt.add_required("sky model file", "The output OSKAR sky model file name to save.");
opt.add_flag("-s", "Spectral index. This is the spectral index that will "
"be given to each pixel in the output sky model.", 1, "0.0");
opt.add_flag("-f", "Minimum allowed fraction of image peak. Pixel values "
"below this fraction will be ignored.", 1, "0.0");
opt.add_flag("-n", "Noise floor in units of original image. "
"Pixels below this value will be ignored.", 1, "0.0");
if (!opt.check_options(argc, argv)) return EXIT_FAILURE;
// Parse command line.
double spectral_index = 0.0;
double min_peak_fraction = 0.0;
double min_abs_val = 0.0;
opt.get("-f")->getDouble(min_peak_fraction);
opt.get("-n")->getDouble(min_abs_val);
opt.get("-s")->getDouble(spectral_index);
// Load the FITS image data.
oskar_Sky* sky = oskar_sky_from_fits_file(OSKAR_DOUBLE, opt.get_arg(0),
min_peak_fraction, min_abs_val, "Jy/beam", 0, 0.0, spectral_index,
&error);
// Write out the sky model.
oskar_sky_save(opt.get_arg(1), sky, &error);
if (error)
{
oskar_log_error(0, oskar_get_error_string(error));
return error;
}
oskar_sky_free(sky, &error);
return 0;
}
int main(int argc, char** argv)
{
oskar::OptionParser opt("oskar_cuda_system_info", oskar_version_string());
opt.set_description("Display a summary of the available CUDA capability");
if (!opt.check_options(argc, argv)) return EXIT_FAILURE;
// Create the CUDA info structure.
int error = 0;
oskar_CudaInfo* info = oskar_cuda_info_create(&error);
if (error)
{
oskar_log_error(0, "Could not determine CUDA system information (%s)",
oskar_get_error_string(error));
oskar_cuda_info_free(info);
return error;
}
// Log the CUDA system info.
oskar_cuda_info_log(NULL, info);
oskar_cuda_info_free(info);
return 0;
}
int main(int argc, char** argv)
{
// ===== Declare options ==================================================
oskar::OptionParser opt("oskar_vis_to_ascii_table", oskar_version_string());
opt.set_description("Converts an OSKAR visibility binary file to an ASCII "
"table format with the following columns:\n "
"[1] index, [2] baseline-uu, [3] baseline-vv, [4] baseline-ww "
"[5] Real, [6] Imag. "
"The table is written out in baseline-time order where baseline "
"is the fastest varying dimension");
opt.add_required("OSKAR vis file");
opt.add_optional("output file name");
opt.add_flag("-c", "Channel index to write to file. (default = 0)", 1, "0",
false, "--channel");
opt.add_flag("-p", "Polarisation ID to write to file. (default = 0) "
"(0=I, 1=Q, 2=U, 3=V, 4=XX, 5=XY, 6=YX, 7=YY)",
1, "0", false, "--polarisation");
opt.add_flag("-t", "Time index to write to file. (default = all)", 1, "",
false, "--time");
opt.add_flag("-w", "Output baseline coordinates in wavelengths. "
"(default = metres)", false, "--baseline_wavelengths");
opt.add_flag("-h", "Write a summary header in the ASCII table. ");
opt.add_flag("-v", "Verbose mode.");
opt.add_flag("--csv", "Write in CSV format");
opt.add_flag("-s", "Write output table to standard output instead of to file.",
false, "--stdout");
if (!opt.check_options(argc, argv)) return EXIT_FAILURE;
// ===== Read options ====================================================
const char* vis_file = opt.get_arg(0);
std::string txt_file;
if (opt.num_args() == 2)
txt_file = std::string(opt.get_arg(1));
else {
txt_file = std::string(vis_file) + ".txt";
}
int c = 0, p = 0, t = -1;
if (opt.is_set("-c")) c = opt.get_int("-c");
if (opt.is_set("-p")) p = opt.get_int("-p");
if (opt.is_set("-t")) t = opt.get_int("-t");
bool metres = !opt.is_set("-w");
bool write_header = opt.is_set("-h");
bool csv = opt.is_set("--csv");
bool verbose = opt.is_set("-v");
// ===== Write table ======================================================
int status = 0;
oskar_Binary* h = oskar_binary_create(vis_file, 'r', &status);
oskar_Vis* vis = oskar_vis_read(h, &status);
if (status)
{
fprintf(stderr, "ERROR: Unable to read specified visibility file: %s\n",
vis_file);
oskar_vis_free(vis, &status);
oskar_binary_free(h);
return status;
}
oskar_binary_free(h);
int num_chan = oskar_vis_num_channels(vis);
int num_times = oskar_vis_num_times(vis);
int num_baselines = oskar_vis_num_baselines(vis);
int num_pol = oskar_vis_num_pols(vis);
int num_stations = oskar_vis_num_stations(vis);
int total_vis = num_chan * num_times * num_baselines * num_pol;
double freq_start_hz = oskar_vis_freq_start_hz(vis);
double freq_inc_hz = oskar_vis_freq_inc_hz(vis);
double freq_hz = freq_start_hz + c * freq_inc_hz;
double lambda_m = 299792458.0 / freq_hz;
if (t != -1 && t > num_times-1) {
fprintf(stderr, "ERROR: Time index out of range.\n");
return EXIT_FAILURE;
}
if (c > num_chan-1) {
fprintf(stderr, "ERROR: Channel index out of range.\n");
return EXIT_FAILURE;
}
FILE* out;
if (!opt.is_set("-s")) {
out = fopen(txt_file.c_str(), "w");
if (out == NULL) return EXIT_FAILURE;
}
else {
out = stdout;
}
const oskar_Mem* uu = oskar_vis_baseline_uu_metres_const(vis);
const oskar_Mem* vv = oskar_vis_baseline_vv_metres_const(vis);
const oskar_Mem* ww = oskar_vis_baseline_ww_metres_const(vis);
const oskar_Mem* amp = oskar_vis_amplitude_const(vis);
// amplitudes dims: channel x times x baselines x pol
int amp_offset = c * num_times * num_baselines;
if (t != -1) amp_offset += t * num_baselines;
// baseline dims: times x baselines
int baseline_offset = 0;
if (t != -1) baseline_offset = t * num_baselines;
int type = oskar_mem_type(uu);
int num_vis_out = num_baselines;
if (t == -1) num_vis_out *= num_times;
if (verbose) {
write_header_(stdout, total_vis, num_chan, num_times, num_baselines,
num_pol, num_stations, num_vis_out, c, freq_hz, lambda_m, p, t,
metres);
#if 0
fprintf(stdout, "amp_offset = %i\n", amp_offset);
fprintf(stdout, "baseline_offset = %i\n", baseline_offset);
#endif
}
// Write header if specified
if (write_header)
{
write_header_(out, total_vis, num_chan, num_times, num_baselines,
num_pol, num_stations, num_vis_out, c, freq_hz, lambda_m, p, t,
metres);
char pre = '#';
fprintf(out, "%c\n", pre);
fprintf(out, "%c %s %-14s %-15s %-15s %-23s %-15s\n",
pre, "Idx", " uu", " vv", " ww", " Amp. Re.", " Amp. Im.");
}
if (type == OSKAR_DOUBLE)
{
const double* uu_ = oskar_mem_double_const(uu, &status);
const double* vv_ = oskar_mem_double_const(vv, &status);
const double* ww_ = oskar_mem_double_const(ww, &status);
const double4c* amp_ = oskar_mem_double4c_const(amp, &status);
int aIdx = amp_offset;
int bIdx = baseline_offset;
for (int i = 0; i < num_vis_out; ++i, ++bIdx, ++aIdx)
{
double2 a = getPolAmp_<double2, double4c>(amp_[aIdx], p);
double buu = (metres)? uu_[bIdx] : uu_[bIdx]/lambda_m;
double bvv = (metres)? vv_[bIdx] : vv_[bIdx]/lambda_m;
double bww = (metres)? ww_[bIdx] : ww_[bIdx]/lambda_m;
writeData_<double, double2>(i, buu, bvv, bww, a, csv, out);
}
}
else // OSKAR_SINGLE
{
const float* uu_ = oskar_mem_float_const(uu, &status);
const float* vv_ = oskar_mem_float_const(vv, &status);
const float* ww_ = oskar_mem_float_const(ww, &status);
const float4c* amp_ = oskar_mem_float4c_const(amp, &status);
int aIdx = amp_offset;
int bIdx = baseline_offset;
for (int i = 0; i < num_vis_out; ++i, ++bIdx, ++aIdx)
{
float2 a = getPolAmp_<float2, float4c>(amp_[aIdx], p);
float buu = (metres)? uu_[bIdx] : uu_[bIdx]/lambda_m;
float bvv = (metres)? vv_[bIdx] : vv_[bIdx]/lambda_m;
float bww = (metres)? ww_[bIdx] : ww_[bIdx]/lambda_m;
writeData_<float, float2>(i, buu, bvv, bww, a, csv, out);
}
}
fclose(out);
oskar_vis_free(vis, &status);
return status;
}
int main(int argc, char** argv)
{
int status = 0;
oskar::OptionParser opt("oskar_evaulate_pierce_points",
oskar_version_string());
opt.add_required("settings file");
if (!opt.check_options(argc, argv)) return EXIT_FAILURE;
const char* settings_file = opt.get_arg();
// Create the log.
oskar_Log* log = oskar_log_create(OSKAR_LOG_MESSAGE, OSKAR_LOG_STATUS);
oskar_log_message(log, 'M', 0, "Running binary %s", argv[0]);
// Enum values used in writing time-freq data binary files
enum OSKAR_TIME_FREQ_TAGS
{
TIME_IDX = 0,
FREQ_IDX = 1,
TIME_MJD_UTC = 2,
FREQ_HZ = 3,
NUM_FIELDS = 4,
NUM_FIELD_TAGS = 5,
HEADER_OFFSET = 10,
DATA = 0,
DIMS = 1,
LABEL = 2,
UNITS = 3,
GRP = OSKAR_TAG_GROUP_TIME_FREQ_DATA
};
oskar_Settings_old settings;
oskar_settings_old_load(&settings, log, settings_file, &status);
oskar_log_set_keep_file(log, settings.sim.keep_log_file);
if (status) return status;
oskar_Telescope* tel = oskar_settings_to_telescope(&settings, log, &status);
oskar_Sky* sky = oskar_settings_to_sky(&settings, log, &status);
// FIXME remove this restriction ... (see evaluate Z)
if (settings.ionosphere.num_TID_screens != 1)
return OSKAR_ERR_SETUP_FAIL;
int type = settings.sim.double_precision ? OSKAR_DOUBLE : OSKAR_SINGLE;
int loc = OSKAR_CPU;
int num_sources = oskar_sky_num_sources(sky);
oskar_Mem *hor_x, *hor_y, *hor_z;
hor_x = oskar_mem_create(type, loc, num_sources, &status);
hor_y = oskar_mem_create(type, loc, num_sources, &status);
hor_z = oskar_mem_create(type, loc, num_sources, &status);
oskar_Mem *pp_lon, *pp_lat, *pp_rel_path;
int num_stations = oskar_telescope_num_stations(tel);
int num_pp = num_stations * num_sources;
pp_lon = oskar_mem_create(type, loc, num_pp, &status);
pp_lat = oskar_mem_create(type, loc, num_pp, &status);
pp_rel_path = oskar_mem_create(type, loc, num_pp, &status);
// Pierce points for one station (non-owned oskar_Mem pointers)
oskar_Mem *pp_st_lon, *pp_st_lat, *pp_st_rel_path;
pp_st_lon = oskar_mem_create_alias(0, 0, 0, &status);
pp_st_lat = oskar_mem_create_alias(0, 0, 0, &status);
pp_st_rel_path = oskar_mem_create_alias(0, 0, 0, &status);
int num_times = settings.obs.num_time_steps;
double obs_start_mjd_utc = settings.obs.start_mjd_utc;
double dt_dump = settings.obs.dt_dump_days;
// Binary file meta-data
std::string label1 = "pp_lon";
std::string label2 = "pp_lat";
std::string label3 = "pp_path";
std::string units = "radians";
std::string units2 = "";
oskar_Mem *dims = oskar_mem_create(OSKAR_INT, loc, 2, &status);
/* FIXME is this the correct dimension order ?
* FIXME get the MATLAB reader to respect dimension ordering */
oskar_mem_int(dims, &status)[0] = num_sources;
oskar_mem_int(dims, &status)[1] = num_stations;
const char* filename = settings.ionosphere.pierce_points.filename;
oskar_Binary* h = oskar_binary_create(filename, 'w', &status);
double screen_height_m = settings.ionosphere.TID->height_km * 1000.0;
// printf("Number of times = %i\n", num_times);
// printf("Number of stations = %i\n", num_stations);
void *x_, *y_, *z_;
x_ = oskar_mem_void(oskar_telescope_station_true_x_offset_ecef_metres(tel));
y_ = oskar_mem_void(oskar_telescope_station_true_y_offset_ecef_metres(tel));
z_ = oskar_mem_void(oskar_telescope_station_true_z_offset_ecef_metres(tel));
for (int t = 0; t < num_times; ++t)
{
double t_dump = obs_start_mjd_utc + t * dt_dump; // MJD UTC
double gast = oskar_convert_mjd_to_gast_fast(t_dump + dt_dump / 2.0);
for (int i = 0; i < num_stations; ++i)
{
const oskar_Station* station =
oskar_telescope_station_const(tel, i);
double lon = oskar_station_lon_rad(station);
double lat = oskar_station_lat_rad(station);
double alt = oskar_station_alt_metres(station);
double x_ecef, y_ecef, z_ecef, x_offset, y_offset, z_offset;
if (type == OSKAR_DOUBLE)
{
x_offset = ((double*)x_)[i];
y_offset = ((double*)y_)[i];
z_offset = ((double*)z_)[i];
}
else
{
x_offset = (double)((float*)x_)[i];
y_offset = (double)((float*)y_)[i];
z_offset = (double)((float*)z_)[i];
}
oskar_convert_offset_ecef_to_ecef(1, &x_offset, &y_offset,
&z_offset, lon, lat, alt, &x_ecef, &y_ecef, &z_ecef);
double last = gast + lon;
if (type == OSKAR_DOUBLE)
{
oskar_convert_apparent_ra_dec_to_enu_directions_d(num_sources,
oskar_mem_double_const(oskar_sky_ra_rad_const(sky), &status),
oskar_mem_double_const(oskar_sky_dec_rad_const(sky), &status),
last, lat, oskar_mem_double(hor_x, &status),
oskar_mem_double(hor_y, &status),
oskar_mem_double(hor_z, &status));
}
else
{
oskar_convert_apparent_ra_dec_to_enu_directions_f(num_sources,
oskar_mem_float_const(oskar_sky_ra_rad_const(sky), &status),
oskar_mem_float_const(oskar_sky_dec_rad_const(sky), &status),
last, lat, oskar_mem_float(hor_x, &status),
oskar_mem_float(hor_y, &status),
oskar_mem_float(hor_z, &status));
}
int offset = i * num_sources;
oskar_mem_set_alias(pp_st_lon, pp_lon, offset, num_sources,
&status);
oskar_mem_set_alias(pp_st_lat, pp_lat, offset, num_sources,
&status);
oskar_mem_set_alias(pp_st_rel_path, pp_rel_path, offset,
num_sources, &status);
oskar_evaluate_pierce_points(pp_st_lon, pp_st_lat, pp_st_rel_path,
x_ecef, y_ecef, z_ecef, screen_height_m,
num_sources, hor_x, hor_y, hor_z, &status);
} // Loop over stations.
if (status != 0)
continue;
int index = t; // could be = (num_times * f) + t if we have frequency data
int num_fields = 3;
int num_field_tags = 4;
double freq_hz = 0.0;
int freq_idx = 0;
// Write the header TAGS
oskar_binary_write_int(h, GRP, TIME_IDX, index, t, &status);
oskar_binary_write_double(h, GRP, FREQ_IDX, index, freq_idx, &status);
oskar_binary_write_double(h, GRP, TIME_MJD_UTC, index, t_dump, &status);
oskar_binary_write_double(h, GRP, FREQ_HZ, index, freq_hz, &status);
oskar_binary_write_int(h, GRP, NUM_FIELDS, index, num_fields, &status);
oskar_binary_write_int(h, GRP, NUM_FIELD_TAGS, index, num_field_tags,
&status);
// Write data TAGS (fields)
int field, tagID;
field = 0;
tagID = HEADER_OFFSET + (num_field_tags * field);
oskar_binary_write_mem(h, pp_lon, GRP, tagID + DATA,
index, 0, &status);
oskar_binary_write_mem(h, dims, GRP, tagID + DIMS,
index, 0, &status);
oskar_binary_write(h, OSKAR_CHAR, GRP, tagID + LABEL,
index, label1.size()+1, label1.c_str(), &status);
oskar_binary_write(h, OSKAR_CHAR, GRP, tagID + UNITS,
index, units.size()+1, units.c_str(), &status);
field = 1;
tagID = HEADER_OFFSET + (num_field_tags * field);
oskar_binary_write_mem(h, pp_lat, GRP, tagID + DATA,
index, 0, &status);
oskar_binary_write_mem(h, dims, GRP, tagID + DIMS,
index, 0, &status);
oskar_binary_write(h, OSKAR_CHAR, GRP, tagID + LABEL,
index, label2.size()+1, label2.c_str(), &status);
oskar_binary_write(h, OSKAR_CHAR, GRP, tagID + UNITS,
index, units.size()+1, units.c_str(), &status);
field = 2;
tagID = HEADER_OFFSET + (num_field_tags * field);
oskar_binary_write_mem(h, pp_rel_path, GRP, tagID + DATA,
index, 0, &status);
oskar_binary_write_mem(h, dims, GRP, tagID + DIMS,
index, 0, &status);
oskar_binary_write(h, OSKAR_CHAR, GRP, tagID + LABEL,
index, label3.size()+1, label3.c_str(), &status);
oskar_binary_write(h, OSKAR_CHAR, GRP, tagID + UNITS,
index, units2.size()+1, units2.c_str(), &status);
} // Loop over times
// Close the OSKAR binary file.
oskar_binary_free(h);
// clean up memory
oskar_mem_free(hor_x, &status);
oskar_mem_free(hor_y, &status);
oskar_mem_free(hor_z, &status);
oskar_mem_free(pp_lon, &status);
oskar_mem_free(pp_lat, &status);
oskar_mem_free(pp_rel_path, &status);
oskar_mem_free(pp_st_lon, &status);
oskar_mem_free(pp_st_lat, &status);
oskar_mem_free(pp_st_rel_path, &status);
oskar_mem_free(dims, &status);
oskar_telescope_free(tel, &status);
oskar_sky_free(sky, &status);
// Check for errors.
if (status)
oskar_log_error(log, "Run failed: %s.", oskar_get_error_string(status));
oskar_log_free(log);
return status;
}
