/** Add a sample log (property) with value as string
* @brief AddSampleLog::addStringLog
* @param theRun
* @param propName
* @param propValue
* @param propUnit
*/
void AddSampleLog::addStringLog(Run &theRun, const std::string &propName,
const std::string &propValue,
const std::string &propUnit) {
theRun.addLogData(new PropertyWithValue<std::string>(propName, propValue));
theRun.getProperty(propName)->setUnits(propUnit);
return;
}
/** Add a single value property
* @brief AddSampleLog::addSingleValueProperty
* @param theRun
* @param propName
* @param propValue
* @param propUnit
* @param propNumberType
*/
void AddSampleLog::addSingleValueProperty(Run &theRun,
const std::string &propName,
const std::string &propValue,
const std::string &propUnit,
const std::string &propNumberType) {
// add a single value property, integer or double
bool value_is_int(false);
if (propNumberType != autoTypeOption) {
value_is_int = (propNumberType == intTypeOption);
} else {
int intVal;
if (Strings::convert(propValue, intVal)) {
value_is_int = true;
}
}
// set value
if (value_is_int) {
// convert to integer
int intVal;
int convert_to_int = Strings::convert(propValue, intVal);
if (convert_to_int == 0) {
// spit out error message and set to default value
g_log.error() << "Error interpreting string '" << propValue
<< "' as NumberType Int.";
throw std::runtime_error("Invalie integer input");
}
theRun.addLogData(new PropertyWithValue<int>(propName, intVal));
} else {
// convert to double
double dblVal;
int convert_to_dbl = Strings::convert(propValue, dblVal);
if (convert_to_dbl == 0) {
g_log.error() << "Error interpreting string '" << propValue
<< "' as NumberType Double.";
throw std::runtime_error("Invalid double input.");
}
theRun.addLogData(new PropertyWithValue<double>(propName, dblVal));
g_log.information() << "added property " << propName << " with value "
<< dblVal << "\n";
}
// add unit
theRun.getProperty(propName)->setUnits(propUnit);
return;
}
/**
* Copy logs from the input workspace to the output workspace
* and don't replace any mathcing logs in the output workspace.
*/
void CopyLogs::mergeKeepExisting(
const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) {
for (auto prop : inputLogs) {
// add the log only if it doesn't already exist
if (!outputRun.hasProperty(prop->name())) {
outputRun.addLogData(prop->clone());
}
}
}
/**
* Copy logs from the input workspace to the output workspace
* and don't replace any mathcing logs in the output workspace.
*/
void CopyLogs::mergeKeepExisting(
const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) {
for (auto iter = inputLogs.begin(); iter != inputLogs.end(); ++iter) {
Kernel::Property *prop = *iter;
// add the log only if it doesn't already exist
if (!outputRun.hasProperty(prop->name())) {
outputRun.addLogData(prop->clone());
}
}
}
/**
* Copy logs from the input workspace to the output workspace
* and replace any matching logs with the ones from the input workspace.
*/
void CopyLogs::mergeReplaceExisting(
const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) {
for (auto prop : inputLogs) {
// if the log exists, remove and replace it
if (outputRun.hasProperty(prop->name())) {
outputRun.removeLogData(prop->name());
}
outputRun.addLogData(prop->clone());
}
}
/**
* Copy logs from the input workspace to the output workspace
* and replace any matching logs with the ones from the input workspace.
*/
void CopyLogs::mergeReplaceExisting(
const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) {
for (auto iter = inputLogs.begin(); iter != inputLogs.end(); ++iter) {
Kernel::Property *prop = *iter;
// if the log exists, remove and replace it
if (outputRun.hasProperty(prop->name())) {
outputRun.removeLogData(prop->name());
}
outputRun.addLogData(prop->clone());
}
}
/**
* Wipe any existing logs in the output workspace and replace
* them with the logs from the input workspace.
*/
void CopyLogs::wipeExisting(const std::vector<Kernel::Property *> &inputLogs,
Run &outputRun) {
auto outputLogs = outputRun.getLogData();
// remove each of the logs from the second workspace
for (auto iter = outputLogs.begin(); iter != outputLogs.end(); ++iter) {
outputRun.removeLogData((*iter)->name());
}
// add all the logs from the new workspace
for (auto iter = inputLogs.begin(); iter != inputLogs.end(); ++iter) {
outputRun.addLogData((*iter)->clone());
}
}
/**
* Wipe any existing logs in the output workspace and replace
* them with the logs from the input workspace.
*/
void CopyLogs::wipeExisting(const std::vector<Kernel::Property *> &inputLogs,
Run &outputRun) {
auto outputLogs = outputRun.getLogData();
// remove each of the logs from the second workspace
for (auto &outputLog : outputLogs) {
outputRun.removeLogData(outputLog->name());
}
// add all the logs from the new workspace
for (auto inputLog : inputLogs) {
outputRun.addLogData(inputLog->clone());
}
}
/** Add a sample log as a TimeSeriesProperty
* @brief AddSampleLog::addTimeSeriesProperty
* @param run_obj
* @param prop_name
* @param prop_value
* @param prop_unit
* @param prop_number_type
*/
void AddSampleLog::addTimeSeriesProperty(Run &run_obj,
const std::string &prop_name,
const std::string &prop_value,
const std::string &prop_unit,
const std::string &prop_number_type) {
// set up the number type right
bool is_int_series(false);
if (prop_number_type == intTypeOption) {
// integer type
is_int_series = true;
} else if (prop_number_type == autoTypeOption) {
// auto type. by default
if (prop_value.empty())
g_log.warning("For sample log in TimeSeriesProperty and values are given "
"by MarixWorkspace, the default data type "
"is double.");
else {
// find out the time series data type by prop_value. integer or double
int intVal;
if (Strings::convert(prop_value, intVal)) {
is_int_series = true;
}
}
} else if (prop_number_type != doubleTypeOption) {
// unsupported type: anything but double, integer or auto
g_log.error() << "TimeSeriesProperty with data type " << prop_number_type
<< " is not supported.\n";
throw std::runtime_error("Unsupported TimeSeriesProperty type.");
}
// check using workspace or some specified start value
std::string tsp_ws_name = getPropertyValue("TimeSeriesWorkspace");
bool use_ws = !tsp_ws_name.empty();
bool use_single_value = !prop_value.empty();
if (use_ws && use_single_value) {
throw std::runtime_error("Both TimeSeries workspace and sing value are "
"specified. It is not allowed.");
} else if (!use_ws && !use_single_value) {
throw std::runtime_error("Neither TimeSeries workspace or sing value are "
"specified. It is not allowed.");
}
// create workspace
// get run start
Types::Core::DateAndTime startTime = getRunStart(run_obj);
// initialze the TimeSeriesProperty and add unit
if (is_int_series) {
auto tsp = new TimeSeriesProperty<int>(prop_name);
if (use_single_value) {
int intVal;
if (Strings::convert(prop_value, intVal)) {
tsp->addValue(startTime, intVal);
} else {
throw std::invalid_argument(
"Input value cannot be converted to an integer value.");
}
}
run_obj.addLogData(tsp);
} else {
auto tsp = new TimeSeriesProperty<double>(prop_name);
if (use_single_value) {
double dblVal;
if (Strings::convert(prop_value, dblVal)) {
tsp->addValue(startTime, dblVal);
} else {
throw std::invalid_argument(
"Input value cannot be converted to a double number.");
}
}
run_obj.addLogData(tsp);
}
// add unit
run_obj.getProperty(prop_name)->setUnits(prop_unit);
if (use_ws)
setTimeSeriesData(run_obj, prop_name, is_int_series);
}
