C++ IAlgorithm_sptr::name方法代码示例

/**
 * 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();
}