// Istrument name remapper.
void qsamplerChannel::updateInstrumentName (void)
{
#ifndef CONFIG_INSTRUMENT_NAME
m_sInstrumentName = getInstrumentName(m_sInstrumentFile,
m_iInstrumentNr, (options() && options()->bInstrumentNames));
#endif
}
// Special instrument file/name/number settler.
bool qsamplerChannel::setInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
{
m_sInstrumentFile = sInstrumentFile;
m_iInstrumentNr = iInstrumentNr;
#ifdef CONFIG_INSTRUMENT_NAME
m_sInstrumentName = QString::null; // We'll get it, maybe later, on channel_info...
#else
m_sInstrumentName = getInstrumentName(sInstrumentFile, iInstrumentNr, true);
#endif
m_iInstrumentStatus = 0;
return true;
}
/**
* Load data from the given files into a struct
* @param files :: [input] List of files to load
* @returns :: struct with loaded data
*/
LoadResult MuonAnalysisDataLoader::loadFiles(const QStringList &files) const {
if (files.empty())
throw std::invalid_argument("Supplied list of files is empty");
// Convert list of files into a mangled map key
const auto toString = [](QStringList qsl) {
std::ostringstream oss;
qsl.sort();
for (const QString &qs : qsl) {
oss << qs.toStdString() << ",";
}
return oss.str();
};
// Clean cache from stale files etc
updateCache();
// Check cache to see if we've loaded this set of files before
const std::string fileString = toString(files);
if (m_loadedDataCache.find(fileString) != m_loadedDataCache.end()) {
g_log.information("Using cached workspace for file(s): " + fileString);
return m_loadedDataCache[fileString];
}
LoadResult result;
std::vector<Workspace_sptr> loadedWorkspaces;
std::string instrName; // Instrument name all the run files should belong to
// Go through all the files and try to load them
for (const auto &fileName : files) {
std::string file = fileName.toStdString();
// Set up load algorithm
IAlgorithm_sptr load =
AlgorithmManager::Instance().createUnmanaged("LoadMuonNexus");
load->initialize();
load->setChild(true);
load->setPropertyValue("Filename", file);
// Just to pass validation
load->setPropertyValue("OutputWorkspace", "__NotUsed");
if (fileName == files.first()) {
// These are only needed for the first file
if (m_deadTimesType == DeadTimesType::FromFile) {
load->setPropertyValue("DeadTimeTable", "__NotUsed");
}
load->setPropertyValue("DetectorGroupingTable", "__NotUsed");
}
load->execute();
Workspace_sptr loadedWorkspace = load->getProperty("OutputWorkspace");
if (fileName == files.first()) {
instrName = getInstrumentName(loadedWorkspace);
// Check that it is a valid Muon instrument
if (!m_instruments.contains(QString::fromStdString(instrName),
Qt::CaseInsensitive)) {
if (0 != instrName.compare("DEVA")) {
// special case - no IDF but let it load anyway
throw std::runtime_error("Instrument is not recognized: " +
instrName);
}
}
if (m_deadTimesType == DeadTimesType::FromFile) {
result.loadedDeadTimes = load->getProperty("DeadTimeTable");
}
result.loadedGrouping = load->getProperty("DetectorGroupingTable");
result.mainFieldDirection =
static_cast<std::string>(load->getProperty("MainFieldDirection"));
result.timeZero = load->getProperty("TimeZero");
result.firstGoodData = load->getProperty("FirstGoodData");
} else {
if (getInstrumentName(loadedWorkspace) != instrName)
throw std::runtime_error(
"All the files should be produced by the same instrument");
}
loadedWorkspaces.push_back(loadedWorkspace);
}
// Some of the ARGUS data files contain wrong information about the
// instrument main field direction. It is always longitudinal.
if (instrName == "ARGUS") {
result.mainFieldDirection = "longitudinal";
}
if (loadedWorkspaces.size() == 1) {
// If single workspace loaded - use it
Workspace_sptr ws = loadedWorkspaces.front();
result.loadedWorkspace = ws;
result.label = MuonAnalysisHelper::getRunLabel(ws);
} else {
// If multiple workspaces loaded - sum them to get the one to work with
try {
result.loadedWorkspace =
MuonAnalysisHelper::sumWorkspaces(loadedWorkspaces);
} catch (std::exception &e) {
std::ostringstream error;
error << "Unable to sum workspaces together: " << e.what() << "\n";
error << "Make sure they have equal dimensions and number of periods.";
throw std::runtime_error(error.str());
}
result.label = MuonAnalysisHelper::getRunLabel(loadedWorkspaces);
}
// Cache the result if we should so we don't have to load it next time
if (shouldBeCached(files)) {
g_log.information("Caching loaded workspace for file(s): " + fileString);
m_loadedDataCache[fileString] = result;
}
return result;
}
