/** * Queries each registered algorithm and asks it how confident it is that it can * load the given file. The name of the one with the highest confidence is * returned. * @param filename A full file path pointing to an existing file * @return A string containing the name of an algorithm to load the file * @throws Exception::NotFoundError if an algorithm cannot be found */ const boost::shared_ptr<IAlgorithm> FileLoaderRegistryImpl::chooseLoader(const std::string &filename) const { using Kernel::FileDescriptor; using Kernel::NexusDescriptor; m_log.debug() << "Trying to find loader for '" << filename << "'" << std::endl; IAlgorithm_sptr bestLoader; if (NexusDescriptor::isHDF(filename)) { m_log.debug() << filename << " looks like a Nexus file. Checking registered Nexus loaders\n"; bestLoader = searchForLoader<NexusDescriptor, IFileLoader<NexusDescriptor>>( filename, m_names[Nexus], m_log); } else { m_log.debug() << "Checking registered non-HDF loaders\n"; bestLoader = searchForLoader<FileDescriptor, IFileLoader<FileDescriptor>>( filename, m_names[Generic], m_log); } if (!bestLoader) { throw Kernel::Exception::NotFoundError(filename, "Unable to find loader"); } m_log.debug() << "Found loader " << bestLoader->name() << " for file '" << filename << "'" << std::endl; return bestLoader; }
/** Validate the properties together */ std::map<std::string, std::string> LiveDataAlgorithm::validateInputs() { std::map<std::string, std::string> out; const std::string instrument = getPropertyValue("Instrument"); const bool eventListener = LiveListenerFactory::Instance().create(instrument,false)->buffersEvents(); if ( !eventListener && getPropertyValue("AccumulationMethod") == "Add" ) { out["AccumulationMethod"] = "The " + instrument + " live stream produces histograms. Add is not a sensible accumulation method."; } if (this->getPropertyValue("OutputWorkspace").empty()) out["OutputWorkspace"] = "Must specify the OutputWorkspace."; // Validate inputs if (this->hasPostProcessing()) { if (this->getPropertyValue("AccumulationWorkspace").empty()) out["AccumulationWorkspace"] = "Must specify the AccumulationWorkspace parameter if using PostProcessing."; if (this->getPropertyValue("AccumulationWorkspace") == this->getPropertyValue("OutputWorkspace")) out["AccumulationWorkspace"] = "The AccumulationWorkspace must be different than the OutputWorkspace, when using PostProcessing."; } // For StartLiveData and MonitorLiveData, make sure another thread is not already using these names if (this->name() != "LoadLiveData") { /** Validate that the workspace names chosen are not in use already */ std::string outName = this->getPropertyValue("OutputWorkspace"); std::string accumName = this->getPropertyValue("AccumulationWorkspace"); // Check that no other MonitorLiveData thread is running with the same settings auto it = AlgorithmManager::Instance().algorithms().begin(); for (; it != AlgorithmManager::Instance().algorithms().end(); it++) { IAlgorithm_sptr alg = *it; // MonitorLiveData thread that is running, except THIS one. if (alg->name() == "MonitorLiveData" && (alg->getAlgorithmID() != this->getAlgorithmID()) && alg->isRunning()) { if (!accumName.empty() && alg->getPropertyValue("AccumulationWorkspace") == accumName) out["AccumulationWorkspace"] += "Another MonitorLiveData thread is running with the same AccumulationWorkspace.\n" "Please specify a different AccumulationWorkspace name."; if (alg->getPropertyValue("OutputWorkspace") == outName) out["OutputWorkspace"] += "Another MonitorLiveData thread is running with the same OutputWorkspace.\n" "Please specify a different OutputWorkspace name."; } } } return out; }
/** * Add a matrix workspace to the accumulation workspace. * * @param algoName :: Name of algorithm which will be adding the workspaces. * @param accumWS :: accumulation matrix workspace * @param chunkWS :: processed live data chunk matrix workspace */ void LoadLiveData::addMatrixWSChunk(const std::string &algoName, Workspace_sptr accumWS, Workspace_sptr chunkWS) { // Handle the addition of the internal monitor workspace, if present auto accumMW = boost::dynamic_pointer_cast<MatrixWorkspace>(accumWS); auto chunkMW = boost::dynamic_pointer_cast<MatrixWorkspace>(chunkWS); if (accumMW && chunkMW) { auto accumMon = accumMW->monitorWorkspace(); auto chunkMon = chunkMW->monitorWorkspace(); if (accumMon && chunkMon) accumMon += chunkMon; } // Now do the main workspace IAlgorithm_sptr alg = this->createChildAlgorithm(algoName); alg->setProperty("LHSWorkspace", accumWS); alg->setProperty("RHSWorkspace", chunkWS); alg->setProperty("OutputWorkspace", accumWS); alg->execute(); if (!alg->isExecuted()) { throw std::runtime_error("Error when calling " + alg->name() + " to add the chunk of live data. See log."); } else { // Get the output as the generic Workspace type // This step is necessary for when we are operating on MD workspaces // (PlusMD) Property *prop = alg->getProperty("OutputWorkspace"); IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(prop); if (!wsProp) throw std::runtime_error( "The " + alg->name() + " Algorithm's OutputWorkspace property is not a WorkspaceProperty!"); Workspace_sptr temp = wsProp->getWorkspace(); accumWS = temp; // And sort the events, if any doSortEvents(accumWS); } }
void MonitorDlg::update() { if (!m_tree) { m_tree = new QTreeWidget(this); m_tree->setColumnCount(3); m_tree->setSelectionMode(QAbstractItemView::NoSelection); // Make the algorithm name column wider m_tree->setColumnWidth(0, 220); QStringList hList; hList << "Algorithm" << "Progress" << ""; m_tree->setHeaderLabels(hList); QHeaderView *hHeader = (QHeaderView *)m_tree->header(); hHeader->setResizeMode(1, QHeaderView::Stretch); hHeader->setResizeMode(2, QHeaderView::Fixed); hHeader->setStretchLastSection(false); } else m_tree->clear(); if (!isVisible()) return; m_algMonitor->lock(); QVector<Mantid::API::AlgorithmID>::const_iterator iend = m_algMonitor->algorithms().end(); for (QVector<Mantid::API::AlgorithmID>::const_iterator itr = m_algMonitor->algorithms().begin(); itr != iend; ++itr) { IAlgorithm_sptr alg = Mantid::API::AlgorithmManager::Instance().getAlgorithm(*itr); // m_algorithms << alg; QStringList iList; iList << QString::fromStdString(alg->name()); QTreeWidgetItem *algItem = new QTreeWidgetItem(iList); m_tree->addTopLevelItem(algItem); QProgressBar *algProgress = new QProgressBar; algProgress->setAlignment(Qt::AlignHCenter); AlgButton *cancelButton = new AlgButton("Cancel", alg); m_tree->setItemWidget(algItem, 1, algProgress); m_tree->setItemWidget(algItem, 2, cancelButton); const std::vector<Mantid::Kernel::Property *> &prop_list = alg->getProperties(); for (std::vector<Mantid::Kernel::Property *>::const_iterator prop = prop_list.begin(); prop != prop_list.end(); ++prop) { QStringList lstr; Mantid::Kernel::MaskedProperty<std::string> *maskedProp = dynamic_cast<Mantid::Kernel::MaskedProperty<std::string> *>(*prop); if (maskedProp) { lstr << QString::fromStdString(maskedProp->name()) + ": " << QString::fromStdString(maskedProp->getMaskedValue()); } else { lstr << QString::fromStdString((**prop).name()) + ": " << QString::fromStdString((**prop).value()); } if ((**prop).isDefault()) lstr << " Default"; algItem->addChild(new QTreeWidgetItem(lstr)); } connect( cancelButton, SIGNAL(clicked(Mantid::API::AlgorithmID, QPushButton *)), m_algMonitor, SLOT(cancel(Mantid::API::AlgorithmID, QPushButton *))); } m_algMonitor->unlock(); }