/** Parse profile table workspace to a map (the new ...
*/
void SaveGSASInstrumentFile::parseProfileTableWorkspace(
ITableWorkspace_sptr ws,
map<unsigned int, map<string, double>> &profilemap) {
size_t numbanks = ws->columnCount() - 1;
size_t numparams = ws->rowCount();
vector<map<string, double>> vec_maptemp(numbanks);
vector<unsigned int> vecbankindex(numbanks);
// Check
vector<string> colnames = ws->getColumnNames();
if (colnames[0].compare("Name"))
throw runtime_error("The first column must be Name");
// Parse
for (size_t irow = 0; irow < numparams; ++irow) {
TableRow tmprow = ws->getRow(irow);
string parname;
tmprow >> parname;
if (parname.compare("BANK")) {
for (size_t icol = 0; icol < numbanks; ++icol) {
double tmpdbl;
tmprow >> tmpdbl;
vec_maptemp[icol].insert(make_pair(parname, tmpdbl));
}
} else {
for (size_t icol = 0; icol < numbanks; ++icol) {
double tmpint;
tmprow >> tmpint;
vecbankindex[icol] = static_cast<unsigned int>(tmpint);
}
}
}
/** Constructor
@param tableWorkspace : The table workspace to wrap
@param whitelist : A DataProcessorWhiteList containing the columns
*/
QDataProcessorOneLevelTreeModel::QDataProcessorOneLevelTreeModel(
ITableWorkspace_sptr tableWorkspace,
const DataProcessorWhiteList &whitelist)
: m_tWS(tableWorkspace), m_whitelist(whitelist) {
if (tableWorkspace->columnCount() != m_whitelist.size())
throw std::invalid_argument(
"Invalid table workspace. Table workspace must "
"have the same number of columns as the white list");
}
/** Constructor
@param tableWorkspace : The table workspace to wrap
@param whitelist : A DataProcessorWhiteList containing information about the
columns, their indices and descriptions
*/
QDataProcessorTreeModel::QDataProcessorTreeModel(
ITableWorkspace_sptr tableWorkspace,
const DataProcessorWhiteList &whitelist)
: m_tWS(tableWorkspace), m_whitelist(whitelist) {
if (tableWorkspace->columnCount() != m_whitelist.size() + 1)
throw std::invalid_argument("Invalid table workspace. Table workspace must "
"have one extra column accounting for groups");
setupModelData(tableWorkspace);
}
/**
* Executes the algorithm.
*/
void LoadTBL::exec() {
std::string filename = getProperty("Filename");
std::ifstream file(filename.c_str());
if (!file) {
throw Exception::FileError("Unable to open file: ", filename);
}
std::string line;
ITableWorkspace_sptr ws = WorkspaceFactory::Instance().createTable();
std::vector<std::string> columnHeadings;
Kernel::Strings::extractToEOL(file, line);
// We want to check if the first line contains an empty string or series of
// ",,,,,"
// to see if we are loading a TBL file that actually contains data or not.
boost::split(columnHeadings, line, boost::is_any_of(","),
boost::token_compress_off);
for (auto entry = columnHeadings.begin(); entry != columnHeadings.end();) {
if (entry->empty()) {
// erase the empty values
entry = columnHeadings.erase(entry);
} else {
// keep any non-empty values
++entry;
}
}
if (columnHeadings.empty()) {
// we have an empty string or series of ",,,,,"
throw std::runtime_error("The file you are trying to load is Empty. \n "
"Please load a non-empty TBL file");
} else {
// set columns back to empty ready to populated with columnHeadings.
columnHeadings.clear();
}
// this will tell us if we need to just fill in the cell values
// or whether we will have to create the column headings as well.
bool isOld = getColumnHeadings(line, columnHeadings);
std::vector<std::string> rowVec;
if (isOld) {
/**THIS IS ESSENTIALLY THE OLD LoadReflTBL CODE**/
// create the column headings
auto colStitch = ws->addColumn("str", "StitchGroup");
auto colRuns = ws->addColumn("str", "Run(s)");
auto colTheta = ws->addColumn("str", "ThetaIn");
auto colTrans = ws->addColumn("str", "TransRun(s)");
auto colQmin = ws->addColumn("str", "Qmin");
auto colQmax = ws->addColumn("str", "Qmax");
auto colDqq = ws->addColumn("str", "dq/q");
auto colScale = ws->addColumn("str", "Scale");
auto colOptions = ws->addColumn("str", "Options");
auto colHiddenOptions = ws->addColumn("str", "HiddenOptions");
for (size_t i = 0; i < ws->columnCount(); i++) {
auto col = ws->getColumn(i);
col->setPlotType(0);
}
// we are using the old ReflTBL format
// where all of the entries are on one line
// so we must reset the stream to reread the first line.
std::ifstream file(filename.c_str());
if (!file) {
throw Exception::FileError("Unable to open file: ", filename);
}
std::string line;
int stitchID = 1;
while (Kernel::Strings::extractToEOL(file, line)) {
if (line.empty() || line == ",,,,,,,,,,,,,,,,") {
continue;
}
getCells(line, rowVec, 16, isOld);
const std::string scaleStr = rowVec.at(16);
const std::string stitchStr = boost::lexical_cast<std::string>(stitchID);
// check if the first run in the row has any data associated with it
// 0 = runs, 1 = theta, 2 = trans, 3 = qmin, 4 = qmax
if (!rowVec[0].empty() || !rowVec[1].empty() || !rowVec[2].empty() ||
!rowVec[3].empty() || !rowVec[4].empty()) {
TableRow row = ws->appendRow();
row << stitchStr;
for (int i = 0; i < 5; ++i) {
row << rowVec.at(i);
}
row << rowVec.at(15);
row << scaleStr;
}
// check if the second run in the row has any data associated with it
// 5 = runs, 6 = theta, 7 = trans, 8 = qmin, 9 = qmax
if (!rowVec[5].empty() || !rowVec[6].empty() || !rowVec[7].empty() ||
!rowVec[8].empty() || !rowVec[9].empty()) {
TableRow row = ws->appendRow();
row << stitchStr;
for (int i = 5; i < 10; ++i) {
row << rowVec.at(i);
}
row << rowVec.at(15);
row << scaleStr;
}
// check if the third run in the row has any data associated with it
// 10 = runs, 11 = theta, 12 = trans, 13 = qmin, 14 = qmax
if (!rowVec[10].empty() || !rowVec[11].empty() || !rowVec[12].empty() ||
!rowVec[13].empty() || !rowVec[14].empty()) {
TableRow row = ws->appendRow();
row << stitchStr;
for (int i = 10; i < 17; ++i) {
if (i == 16)
row << scaleStr;
else
row << rowVec.at(i);
}
}
++stitchID;
setProperty("OutputWorkspace", ws);
}
} else {
// we have a TBL format that contains column headings
// on the first row. These are now entries in the columns vector
if (!columnHeadings.empty()) {
// now we need to add the custom column headings from
// the columns vector to the TableWorkspace
for (auto heading = columnHeadings.begin();
heading != columnHeadings.end();) {
if (heading->empty()) {
// there is no need to have empty column headings.
heading = columnHeadings.erase(heading);
} else {
Mantid::API::Column_sptr col;
col = ws->addColumn("str", *heading);
col->setPlotType(0);
heading++;
}
}
}
size_t expectedCommas = columnHeadings.size() - 1;
while (Kernel::Strings::extractToEOL(file, line)) {
if (line.empty() || line == ",,,,,,,,,,,,,,,,") {
// skip over any empty lines
continue;
}
getCells(line, rowVec, columnHeadings.size() - 1, isOld);
// populate the columns with their values for this row.
TableRow row = ws->appendRow();
for (size_t i = 0; i < expectedCommas + 1; ++i) {
row << rowVec.at(i);
}
}
setProperty("OutputWorkspace", ws);
}
}
/**
* Write log and parameter values to the table for the case of multiple fits.
* @param table :: [input, output] Table to write to
* @param paramsByLabel :: [input] Map of <label name, <workspace name,
* <parameter, value>>>
* @param paramsToDisplay :: [input] List of parameters to display in table
*/
void MuonAnalysisResultTableCreator::writeDataForMultipleFits(
ITableWorkspace_sptr &table,
const QMap<QString, WSParameterList> ¶msByLabel,
const QStringList ¶msToDisplay) const {
assert(m_multiple);
assert(m_logValues);
// Add data to table
for (const auto &labelName : m_items) {
Mantid::API::TableRow row = table->appendRow();
size_t columnIndex(0); // Which column we are writing to
row << labelName.toStdString();
columnIndex++;
// Get log values for this row and write in table
for (const auto &log : m_logs) {
QStringList valuesPerWorkspace;
for (const auto &wsName : paramsByLabel[labelName].keys()) {
const auto &logValues = m_logValues->value(wsName);
const auto &val = logValues[log];
auto dashIndex = val.toString().indexOf("-");
// Special case: if log is time in sec, subtract the first start time
if (log.endsWith(" (s)")) {
auto seconds =
val.toDouble() - static_cast<double>(m_firstStart_ns) * 1.e-9;
valuesPerWorkspace.append(QString::number(seconds));
} else if (dashIndex != 0 && dashIndex != -1) {
valuesPerWorkspace.append(logValues[log].toString());
} else if (MuonAnalysisHelper::isNumber(val.toString()) &&
!log.endsWith(" (text)")) {
valuesPerWorkspace.append(QString::number(val.toDouble()));
} else {
valuesPerWorkspace.append(logValues[log].toString());
}
}
// Range of values - use string comparison as works for numbers too
// Why not use std::minmax_element? To avoid MSVC warning: QT bug 41092
// (https://bugreports.qt.io/browse/QTBUG-41092)
valuesPerWorkspace.sort();
auto dashIndex =
valuesPerWorkspace.front().toStdString().find_first_of("-");
if (dashIndex != std::string::npos && dashIndex != 0) {
std::ostringstream oss;
auto dad = valuesPerWorkspace.front().toStdString();
oss << valuesPerWorkspace.front().toStdString();
row << oss.str();
} else {
if (MuonAnalysisHelper::isNumber(valuesPerWorkspace.front())) {
const auto &min = valuesPerWorkspace.front().toDouble();
const auto &max = valuesPerWorkspace.back().toDouble();
if (min == max) {
row << min;
} else {
std::ostringstream oss;
oss << valuesPerWorkspace.front().toStdString() << "-"
<< valuesPerWorkspace.back().toStdString();
row << oss.str();
}
} else {
const auto &front = valuesPerWorkspace.front().toStdString();
const auto &back = valuesPerWorkspace.back().toStdString();
if (front == back) {
row << front;
} else {
std::ostringstream oss;
oss << valuesPerWorkspace[0].toStdString();
for (int k = 1; k < valuesPerWorkspace.size(); k++) {
oss << ", " << valuesPerWorkspace[k].toStdString();
row << oss.str();
}
}
}
}
columnIndex++;
}
// Parse column name - could be param name or f[n].param
const auto parseColumnName =
[¶msToDisplay](
const std::string &columnName) -> std::pair<int, std::string> {
if (paramsToDisplay.contains(QString::fromStdString(columnName))) {
return {0, columnName};
} else {
// column name is f[n].param
size_t pos = columnName.find_first_of('.');
if (pos != std::string::npos) {
try {
const auto ¶mName = columnName.substr(pos + 1);
const auto wsIndex = std::stoi(columnName.substr(1, pos));
return {wsIndex, paramName};
} catch (const std::exception &ex) {
throw std::runtime_error("Failed to parse column name " +
columnName + ": " + ex.what());
}
} else {
throw std::runtime_error("Failed to parse column name " + columnName);
}
}
};
// Add param values
const auto ¶ms = paramsByLabel[labelName];
while (columnIndex < table->columnCount()) {
const auto &parsedColName =
parseColumnName(table->getColumn(columnIndex)->name());
const QString wsName = params.keys().at(parsedColName.first);
const QString ¶mName = QString::fromStdString(parsedColName.second);
row << params[wsName].value(paramName);
columnIndex++;
}
}
}