void ColInOut::impl_configRead(const SettingsTree& settings)
{
m_nSource = settings.readIntRanged(con::KeySource , 2, 0, 8);
m_bAbsolute = settings.readBool (con::KeyAbsolute, false);
m_nAbsTime = settings.readIntRanged(con::KeyAbsTime , 1, 0, 2);
}
void MirandaSettings::writeTree(const char* szSetting, const SettingsTree& value) const
{
writeStr(szSetting, value.toString().c_str());
}
void MirandaSettings::readTree(const char* szSetting, const TCHAR* szDefault, SettingsTree& value) const
{
value.fromString(readStr(szSetting, szDefault));
}
void ColNick::impl_configRead(const SettingsTree& settings)
{
m_bDetail = settings.readBool(con::KeyDetail, true);
m_bContactCount = settings.readBool(con::KeyContactCount, true);
}
void ColNick::impl_configWrite(SettingsTree& settings) const
{
settings.writeBool(con::KeyDetail, m_bDetail);
settings.writeBool(con::KeyContactCount, m_bContactCount);
}
void ColEvents::impl_configRead(const SettingsTree& settings)
{
m_nSource = settings.readIntRanged(con::KeySource, 5, 0, 5);
}
TEST(SettingsTree, test)
{
SettingsTree s;
ASSERT_TRUE(s.add_setting("sky",
"Sky settings",
"description of sky settings"));
ASSERT_TRUE(s.add_setting("sky/file",
"Sky file",
"description of sky file",
"InputFileList"));
ASSERT_TRUE(s.add_setting("sky/generator/type",
"generator type",
"description of generator",
"OptionList",
"b",
"a,b,c"));
ASSERT_TRUE(s.add_setting("telescope/directory",
"telescope dir",
"description",
"InputDirectory",
"", "", true));
ASSERT_EQ(6, s.num_items());
ASSERT_EQ(3, s.num_settings());
ASSERT_EQ("b", s.value("sky/generator/type")->get_value());
ASSERT_TRUE(s.item("telescope/directory")->is_required());
ASSERT_TRUE(s.set_value("sky/file", "sky.osm"));
ASSERT_EQ("sky.osm", s["sky/file"]->get_value());
ASSERT_FALSE(s.contains("a/b/c"));
s.print();
s.clear();
ASSERT_EQ(0, s.num_items());
ASSERT_EQ(0, s.num_settings());
s.begin_group("a");
{
s.add_setting("b","","", "Int");
s.begin_group("c");
{
s.add_setting("d", "", "", "Double");
}
s.end_group();
}
s.end_group();
s.print();
s.clear();
ASSERT_FALSE(s.add_setting("key", "", "", "Int", "hello"));
ASSERT_EQ(0, s.num_items());
ASSERT_EQ(0, s.num_settings());
s.clear();
}
TEST(SettingsTree, xml)
{
const char* temp = ""
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<root version=\"2.6.1\">"
" <s k=\"group1\">"
" <label>Label for Group 1</label>"
" <s key=\"key1\"><label>A bool</label>"
" <type name=\"bool\" default=\"false\"/>"
" <desc>"
" This is a bool. The description "
" can span multiple lines like this."
" </desc>"
" </s>"
" <s key=\"key2\">"
" <label>An int</label>"
" <type name=\"int\" default=\"5000\"/>"
" </s>"
" <s key=\"key3\">"
" <type name=\"bool\" default=\"true\"/>"
" <s key=\"key4\">"
" <type name=\"int\" default=\"10\"/>"
" </s>"
" </s>"
" <s k=\"input_file_key\"><label>Input file</label>"
" <type name=\"InputFile\" default=\"\"/>"
" <desc>Pathname to input file.</desc>"
" </s>"
" <s k=\"unsigned_double_key\">"
" <label>An unsigned double</label>"
" <type name=\"UnsignedDouble\" default=\"0.0\"/>"
" <desc>This is an unsigned double.</desc>"
" </s>"
" <s k=\"list_key\"><label>A list</label>"
" <type name=\"OptionList\" default=\"XY\">XY,X,Y</type>"
" <desc>This is a list.</desc>"
" </s>"
" <s k=\"uint_key\">"
" <label>An unsigned int</label>"
" <type name=\"uint\" default=\"0\"/>"
" <desc>This is an unsigned int.</desc>"
" </s>"
" </s>"
" <s key=\"group2\">"
" <!-- Setting with simple dependency -->"
" <s key=\"simple_deps\">"
" <type name=\"string\" default=\"\"/>"
" <d k=\"group1/key1\" v=\"true\"/>"
" <d k=\"group1/key2\" v=\"5\"/>"
" </s>"
" <!-- Setting with more complicated dependency logic -->"
" <s key=\"nested_deps\">"
" <type name=\"string\" default=\"\"/>"
" <logic group=\"OR\">"
" <d k=\"group1/key1\" c=\"NE\" v=\"true\"/>"
" <l g=\"OR\">"
" <d k=\"group1/key2\" c=\"GT\" v=\"200\"/>"
" <d k=\"group1/key3\" c=\"EQ\" v=\"false\"/>"
" </l>"
" <d k=\"group1/key3/key4\" c=\"EQ\" v=\"2\"/>"
" </l>"
" </s>"
" </s>"
"</root>";
// Create the settings tree and declare settings using XML.
SettingsTree s;
ASSERT_TRUE(settings_declare_xml(&s, temp));
// Get a value out of the tree and check it.
int status = 0;
ASSERT_EQ(5000, s.to_int("group1/key2", &status));
ASSERT_EQ(0, status);
// Print the settings tree.
s.print();
}
TEST(SettingsTree, simple_deps)
{
SettingsTree s;
s.add_setting("keyA", "", "", "Bool", "false");
s.add_setting("keyB");
s.add_dependency("keyA", "true", "EQ");
s.add_setting("keyC");
s.add_dependency("KeyA", "true", "EQ");
ASSERT_EQ(0, s.item("keyA")->num_dependencies());
ASSERT_EQ(1, s.item("keyB")->num_dependencies());
EXPECT_FALSE(s.dependencies_satisfied("keyB"));
ASSERT_TRUE(s.set_value("keyA", "true"));
ASSERT_EQ("true", s.value("keyA")->get_value());
ASSERT_EQ("true", s["keyA"]->get_value());
ASSERT_TRUE(s.dependencies_satisfied("KEYB"));
}
void ColSplitTimeline::impl_configWrite(SettingsTree& settings) const
{
settings.writeInt (con::KeySource, m_nSource);
settings.writeInt (con::KeySourceType, m_nSourceType);
settings.writeInt (con::KeyIgnoreOld, m_nIgnoreOld);
settings.writeInt (con::KeyVisMode, m_nVisMode);
settings.writeInt (con::KeyHODGroup, m_nHODGroup);
settings.writeInt (con::KeyDOWGroup, m_nDOWGroup);
settings.writeInt (con::KeyBlockUnit, m_nBlockUnit);
settings.writeInt (con::KeyUnitsPerBlock, m_nUnitsPerBlock);
settings.writeInt (con::KeyBlocks, m_nBlocks);
settings.writeInt (con::KeyGraphAlign, m_nGraphAlign);
settings.writeInt (con::KeyCustomGroup, m_nCustomGroup);
settings.writeBool(con::KeyTopPerColumn, m_bTopPerColumn);
}
int main(int argc, char** argv)
{
int status = 0;
vector<pair<string, string> > failed_keys;
// Obtain command line options & arguments.
OptionParser opt("oskar_vis_add_noise", oskar_version_string(),
settings_def);
opt.set_description("Application to add noise to OSKAR binary visibility "
"files.");
opt.add_required("OSKAR visibility file(s)...");
opt.add_flag("-s", "OSKAR settings file (noise settings).", 1, "", true);
opt.add_flag("-v", "Verbose logging.");
opt.add_flag("-q", "Suppress all logging output.");
if (!opt.check_options(argc, argv))
return EXIT_FAILURE;
string settings_file;
opt.get("-s")->getString(settings_file);
vector<string> vis_filename_in = opt.get_input_files();
int num_files = vis_filename_in.size();
bool verbose = opt.is_set("-v") ? true : false;
bool quiet = opt.is_set("-q") ? true : false;
// Declare settings.
SettingsTree s;
settings_declare_xml(&s, settings_def);
SettingsFileHandlerIni handler("oskar_vis_add_noise",
oskar_version_string());
s.set_file_handler(&handler);
// Create the log.
int file_priority = OSKAR_LOG_MESSAGE;
int term_priority = OSKAR_LOG_STATUS;
if (quiet) term_priority = OSKAR_LOG_WARNING;
if (verbose) term_priority = OSKAR_LOG_DEBUG;
oskar_Log* log = oskar_log_create(file_priority, term_priority);
oskar_log_set_keep_file(log, false);
oskar_log_message(log, 'M', 0, "Running binary %s", argv[0]);
// Load the settings file.
oskar_log_section(log, 'M', "Loading settings file '%s'", settings_file);
if (!s.load(settings_file, failed_keys))
{
oskar_log_error(log, "Failed to read settings file.");
oskar_log_free(log);
return OSKAR_ERR_FILE_IO;
}
// Write settings to log.
oskar_settings_log(&s, log, failed_keys);
if (!s.to_int("interferometer/noise/enable", &status))
{
oskar_log_error(log, "Noise addition disabled in the settings.");
oskar_log_free(log);
return EXIT_FAILURE;
}
// Set up the telescope model.
oskar_Telescope* tel = oskar_settings_to_telescope(&s, log, &status);
oskar_telescope_analyse(tel, &status);
if (status)
{
oskar_log_error(log, "Error: %s", oskar_get_error_string(status));
oskar_telescope_free(tel, &status);
oskar_log_free(log);
return EXIT_FAILURE;
}
// Create list of output vis file names.
vector<string> vis_filename_out(num_files);
for (int i = 0; i < (int)vis_filename_out.size(); ++i)
{
string str = vis_filename_in[i];
if (!oskar_file_exists(str.c_str())) {
oskar_log_error(log, "Visibility file %s not found.", str.c_str());
oskar_log_free(log);
return EXIT_FAILURE;
}
// TODO check if the file exists
str.erase(str.end()-4, str.end());
vis_filename_out[i] = str + "_noise.vis";
}
// Print a summary of what is about to happen.
oskar_log_line(log, 'D', ' ');
oskar_log_line(log, 'D', '-');
oskar_log_value(log, 'D', -1, "Number of input files", "%li", num_files);
for (int i = 0; i < num_files; ++i)
oskar_log_message(log, 'D', 1, "%s", vis_filename_in[i].c_str());
oskar_log_value(log, 'D', -1, "Settings file", "%s", settings_file.c_str());
oskar_log_value(log, 'D', -1, "Verbose", "%s", (verbose?"true":"false"));
oskar_log_line(log, 'D', '-');
// Add uncorrelated noise to each of the visibility files.
for (int i = 0; i < num_files; ++i)
{
if (status) break;
const char* in_file = vis_filename_in[i].c_str();
const char* out_file = vis_filename_out[i].c_str();
oskar_log_line(log, 'D', ' ');
oskar_log_value(log, 'D', -1, "Loading visibility file", "%s", in_file);
// Load the input file and create the output file.
oskar_Binary* h_in = oskar_binary_create(in_file, 'r', &status);
oskar_VisHeader* hdr = oskar_vis_header_read(h_in, &status);
oskar_Binary* h_out = oskar_vis_header_write(hdr, out_file, &status);
// TODO Check that the visibility file was written with normalise
// beam mode enabled. If not print a warning.
// TODO Also verify any settings in the vis file against those loaded.
// Get header data.
int max_times_per_block = oskar_vis_header_max_times_per_block(hdr);
int num_times = oskar_vis_header_num_times_total(hdr);
int num_blocks = (num_times + max_times_per_block - 1) /
max_times_per_block;
int type = oskar_vis_header_coord_precision(hdr);
oskar_Mem* station_work = oskar_mem_create(type, OSKAR_CPU, 0, &status);
// Create a visibility block to read into.
oskar_VisBlock* blk = oskar_vis_block_create_from_header(OSKAR_CPU,
hdr, &status);
// Loop over blocks.
for (int b = 0; b < num_blocks; ++b)
{
// Check for errors.
if (status) break;
// Read the block.
oskar_vis_block_read(blk, hdr, h_in, b, &status);
// Add noise to the block.
oskar_vis_block_add_system_noise(blk, hdr, tel, b, station_work,
&status);
// Write the block.
oskar_vis_block_write(blk, h_out, b, &status);
}
// Free memory for vis header and vis block, and close files.
oskar_mem_free(station_work, &status);
oskar_vis_block_free(blk, &status);
oskar_vis_header_free(hdr, &status);
oskar_binary_free(h_in);
oskar_binary_free(h_out);
}
// Free telescope model.
oskar_telescope_free(tel, &status);
if (status)
oskar_log_error(log, "Error: %s", oskar_get_error_string(status));
oskar_log_free(log);
return status;
}
void ColSplitTimeline::impl_configRead(const SettingsTree& settings)
{
m_nSource = settings.readIntRanged(con::KeySource, 0, 0, 2);
m_nSourceType = settings.readIntRanged(con::KeySourceType, 2, 0, 3);
m_nIgnoreOld = settings.readIntRanged(con::KeyIgnoreOld, 0, 0, 1000);
m_nVisMode = settings.readIntRanged(con::KeyVisMode, 0, 0, 2);
m_nHODGroup = settings.readIntRanged(con::KeyHODGroup, 1, 1, 1000);
m_nDOWGroup = settings.readIntRanged(con::KeyDOWGroup, 1, 1, 1000);
m_nBlockUnit = settings.readIntRanged(con::KeyBlockUnit, 0, 0, 2);
m_nUnitsPerBlock = settings.readIntRanged(con::KeyUnitsPerBlock, 6, 1, 100);
m_nBlocks = settings.readIntRanged(con::KeyBlocks, 28, 1, 49);
m_nGraphAlign = settings.readIntRanged(con::KeyGraphAlign, 1, 0, 1);
m_nCustomGroup = settings.readIntRanged(con::KeyCustomGroup, 1, 1, 1000);
m_bTopPerColumn = settings.readBool(con::KeyTopPerColumn, true);
}
int main(int argc, char** argv)
{
int e = 0;
vector<pair<string, string> > failed_keys;
oskar_Log* log = 0;
OptionParser opt("oskar_sim_interferometer", oskar_version_string(),
settings_def);
opt.add_settings_options();
opt.add_flag("-q", "Suppress printing.", false, "--quiet");
if (!opt.check_options(argc, argv)) return EXIT_FAILURE;
const char* settings_file = opt.get_arg(0);
// Declare settings.
SettingsTree s;
settings_declare_xml(&s, settings_def);
SettingsFileHandlerIni handler("oskar_sim_interferometer",
oskar_version_string());
s.set_file_handler(&handler);
// Create the log if necessary.
if (!opt.is_set("--get") && !opt.is_set("--set"))
{
int priority = opt.is_set("-q") ? OSKAR_LOG_WARNING : OSKAR_LOG_STATUS;
log = oskar_log_create(OSKAR_LOG_MESSAGE, priority);
oskar_log_message(log, 'M', 0, "Running binary %s", argv[0]);
oskar_log_section(log, 'M', "Loading settings file '%s'", settings_file);
}
// Load the settings file.
if (!s.load(settings_file, failed_keys))
{
oskar_log_error(log, "Failed to read settings file.");
if (log) oskar_log_free(log);
return EXIT_FAILURE;
}
// Get/set setting if necessary.
if (opt.is_set("--get"))
{
printf("%s\n", s.to_string(opt.get_arg(1), &e).c_str());
return !e ? 0 : EXIT_FAILURE;
}
else if (opt.is_set("--set"))
{
const char* key = opt.get_arg(1);
const char* val = opt.get_arg(2);
bool ok = val ? s.set_value(key, val) : s.set_default(key);
if (!ok) oskar_log_error(log, "Failed to set '%s'='%s'", key, val);
return ok ? 0 : EXIT_FAILURE;
}
// Write settings to log.
oskar_settings_log(&s, log, failed_keys);
// Set up the sky model.
oskar_Sky* sky = oskar_settings_to_sky(&s, log, &e);
if (!sky || e)
{
oskar_log_error(log, "Failed to set up sky model: %s.",
oskar_get_error_string(e));
oskar_sky_free(sky, &e);
oskar_log_free(log);
return e;
}
// Set up the telescope model.
oskar_Telescope* tel = oskar_settings_to_telescope(&s, log, &e);
if (!tel || e)
{
oskar_log_error(log, "Failed to set up telescope model: %s.",
oskar_get_error_string(e));
oskar_telescope_free(tel, &e);
oskar_sky_free(sky, &e);
oskar_log_free(log);
return e;
}
// Create simulator and set values from settings.
s.begin_group("simulator");
int prec = s.to_int("double_precision", &e) ? OSKAR_DOUBLE : OSKAR_SINGLE;
int max_sources_per_chunk = s.to_int("max_sources_per_chunk", &e);
oskar_Simulator* h = oskar_simulator_create(prec, &e);
oskar_simulator_set_log(h, log);
oskar_simulator_set_settings_path(h, settings_file);
if (!s.to_int("use_gpus", &e))
oskar_simulator_set_gpus(h, 0, 0, &e);
else
{
if (s.starts_with("cuda_device_ids", "all", &e))
oskar_simulator_set_gpus(h, -1, 0, &e);
else
{
vector<int> ids = s.to_int_list("cuda_device_ids", &e);
if (ids.size() > 0)
oskar_simulator_set_gpus(h, ids.size(), &ids[0], &e);
}
}
if (s.starts_with("num_devices", "auto", &e))
oskar_simulator_set_num_devices(h, -1);
else
oskar_simulator_set_num_devices(h, s.to_int("num_devices", &e));
oskar_log_set_keep_file(log, s.to_int("keep_log_file", &e));
oskar_log_set_file_priority(log, s.to_int("write_status_to_log_file", &e) ?
OSKAR_LOG_STATUS : OSKAR_LOG_MESSAGE);
s.end_group();
// Set sky settings.
s.begin_group("sky");
oskar_simulator_set_horizon_clip(h,
s.to_int("advanced/apply_horizon_clip", &e));
oskar_simulator_set_zero_failed_gaussians(h,
s.to_int("advanced/zero_failed_gaussians", &e));
/* FIXME oskar_simulator_set_source_flux_range(h,
s.to_double("common_flux_filter_min_jy", &e),
s.to_double("common_flux_filter_max_jy", &e));*/
s.end_group();
// Set observation settings.
s.begin_group("observation");
int num_time_steps = s.to_int("num_time_steps", &e);
double inc_sec = s.to_double("length", &e) / num_time_steps;
oskar_simulator_set_observation_time(h, s.to_double("start_time_utc", &e),
inc_sec, num_time_steps);
oskar_simulator_set_observation_frequency(h,
s.to_double("start_frequency_hz", &e),
s.to_double("frequency_inc_hz", &e),
s.to_int("num_channels", &e));
s.end_group();
// Set interferometer settings.
s.begin_group("interferometer");
oskar_simulator_set_correlation_type(h,
s.to_string("correlation_type", &e).c_str(), &e);
oskar_simulator_set_max_times_per_block(h,
s.to_int("max_time_samples_per_block", &e));
oskar_simulator_set_output_vis_file(h,
s.to_string("oskar_vis_filename", &e).c_str());
#ifndef OSKAR_NO_MS
oskar_simulator_set_output_measurement_set(h,
s.to_string("ms_filename", &e).c_str());
oskar_simulator_set_force_polarised_ms(h,
s.to_int("force_polarised_ms", &e));
#endif
s.end_group();
// Set the sky model and telescope model.
oskar_simulator_set_sky_model(h, sky, max_sources_per_chunk, &e);
oskar_simulator_set_telescope_model(h, tel, &e);
// Run simulation.
oskar_Timer* tmr = oskar_timer_create(OSKAR_TIMER_NATIVE);
oskar_timer_resume(tmr);
oskar_simulator_run(h, &e);
// Check for errors.
if (!e)
oskar_log_message(log, 'M', 0, "Simulation completed in %.3f sec.",
oskar_timer_elapsed(tmr));
else
oskar_log_error(log, "Run failed with code %i: %s.", e,
oskar_get_error_string(e));
// Free memory.
oskar_sky_free(sky, &e);
oskar_telescope_free(tel, &e);
oskar_timer_free(tmr);
oskar_simulator_free(h, &e);
oskar_log_free(log);
return e;
}
void ColEvents::impl_configWrite(SettingsTree& settings) const
{
settings.writeInt(con::KeySource, m_nSource);
}
void ColInOut::impl_configWrite(SettingsTree& settings) const
{
settings.writeInt (con::KeySource , m_nSource );
settings.writeBool(con::KeyAbsolute, m_bAbsolute);
settings.writeInt (con::KeyAbsTime , m_nAbsTime );
}
TEST(SettingsTree, nested_deps)
{
SettingsTree s;
s.add_setting("keyA1", "", "", "Bool", "false");
s.add_setting("keyA2", "", "", "Int", "2");
s.add_setting("keyB");
s.begin_dependency_group("AND");
s.add_dependency("KeyA1", "true", "EQ");
s.add_dependency("KeyA2", "3", "GT");
s.end_dependency_group();
ASSERT_EQ(0, s.item("keyA1")->num_dependencies());
ASSERT_EQ(0, s.item("keyA2")->num_dependencies());
ASSERT_EQ(2, s.item("keyB")->num_dependencies());
ASSERT_FALSE(s.dependencies_satisfied("keyB"));
ASSERT_TRUE(s.set_value("keyA1", "true"));
ASSERT_TRUE(s.set_value("keyA2", "5"));
ASSERT_TRUE(s.dependencies_satisfied("keyB"));
}
TEST(SettingsTree, test2)
{
SettingsTree s;
s.add_setting("g1", "group 1", "description of group 1");
s.begin_group("g1");
{
s.add_setting("b", "setting b", "", "Int");
s.add_setting("c", "OptionList", "description for c", "OptionList",
"", "opt1, opt2, opt3, opt4", true);
s.add_setting("d", "setting d", "description or d", "InputFile",
"", "", true);
s.begin_dependency_group("OR");
s.add_dependency("g1/b", "3", "GE");
s.add_dependency("g1/c", "opt4", "EQ");
s.end_dependency_group();
s.end_group();
}
s.begin_group("g2");
{
s.add_setting("DoubleRangeExt", "DoubleRangeExt", "",
"DoubleRangeExt", "min", "-DBL_MIN,DBL_MAX,min");
s.add_setting("IntRangeExt", "IntRangeExt", "",
"IntRangeExt", "5", "-1,INT_MAX,min");
s.end_group();
}
s.begin_group("g3");
{
s.begin_group("g4");
{
s.add_setting("IntListExt", "IntListExt", "",
"IntListExt", "1,2,3", "all");
s.end_group();
}
s.add_setting("Double1", "Double1", "", "Double", "-10.0");
s.add_setting("Double2", "Double2", "", "Double", "100.0e3");
s.end_group();
}
int status = 0;
ASSERT_EQ(0, s.to_int("g1/b", &status));
ASSERT_EQ(0, status);
ASSERT_TRUE(s.dependencies_satisfied("g1"));
ASSERT_TRUE(s.dependencies_satisfied("g1/b"));
ASSERT_FALSE(s.dependencies_satisfied("g1/d"));
}
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <catch.hpp>
#include <app/appinfo.h>
#include <fstream>
#include <util/settingstree.h>
static const std::string theKey = "foo/bar";
TEST_CASE("Util/SettingsTree/Int")
{
SettingsTree settings;
REQUIRE(settings.get(theKey, -1) == -1);
settings.set(theKey, 1);
REQUIRE(settings.get(theKey, -1) == 1);
settings.set(theKey, 2);
REQUIRE(settings.get(theKey, -1) == 2);
REQUIRE_THROWS(settings.get<std::string>(theKey));
}
TEST_CASE("Util/SettingsTree/Bool")
{
SettingsTree settings;
REQUIRE(settings.get(theKey, true) == true);
settings.set(theKey, false);
