ISISJournalGetExperimentRuns.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2020 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidDataHandling/ISISJournalGetExperimentRuns.h"
#include "MantidAPI/ITableWorkspace.h"
#include "MantidAPI/TableRow.h"
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidAPI/WorkspaceProperty.h"
#include "MantidDataHandling/ISISJournal.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/FacilityInfo.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/MandatoryValidator.h"
 
#include <algorithm>
 
namespace Mantid::DataHandling {
DECLARE_ALGORITHM(ISISJournalGetExperimentRuns)
 
using Mantid::API::IJournal;
using Mantid::API::ITableWorkspace_sptr;
using Mantid::API::TableRow;
using Mantid::DataHandling::ISISJournal;
using Mantid::Kernel::ConfigService;
using Mantid::Kernel::MandatoryValidator;
using Mantid::Kernel::StringListValidator;
 
namespace {
// These strings define the XML tags for the metadata we are going to return or
// filter by
static constexpr const char *INVESTIGATION_ID = "experiment_identifier";
static constexpr const char *RUN_NAME = "name";
static constexpr const char *RUN_NUMBER = "run_number";
static constexpr const char *RUN_TITLE = "title";
 
std::vector<IJournal::RunData> getRuns(IJournal *journal, std::string const &investigationId) {
  static auto valuesToLookup = std::vector<std::string>{RUN_NUMBER, RUN_TITLE};
  auto filters = IJournal::RunData{{INVESTIGATION_ID, investigationId}};
  auto runs = journal->getRuns(valuesToLookup, filters);
  return runs;
}
 
ITableWorkspace_sptr convertRunDataToTable(const std::vector<IJournal::RunData> &runs) {
  auto workspace = API::WorkspaceFactory::Instance().createTable("TableWorkspace");
 
  workspace->addColumn("str", "Name");
  workspace->addColumn("str", "Run Number");
  workspace->addColumn("str", "Title");
 
  for (auto &run : runs) {
    TableRow row = workspace->appendRow();
    const auto runNameIt = run.find(RUN_NAME);
    const auto runNumberIt = run.find(RUN_NUMBER);
    const auto runTitleIt = run.find(RUN_TITLE);
    if (runNameIt != run.cend() && runNumberIt != run.cend() && runTitleIt != run.cend())
      row << runNameIt->second << runNumberIt->second << runTitleIt->second;
  }
  return workspace;
}
 
std::vector<std::string> getInstruments() {
  auto instruments = std::vector<std::string>();
  const auto &instrInfo = ConfigService::Instance().getFacility("ISIS").instruments();
  std::transform(instrInfo.cbegin(), instrInfo.cend(), std::back_inserter(instruments),
                 [](const auto instrument) { return instrument.name(); });
  return instruments;
}
 
std::string getDefaultInstrument(std::vector<std::string> const &instruments) {
  if (instruments.empty())
    return std::string();
 
  auto instrument = ConfigService::Instance().getInstrument().name();
  if (std::find(instruments.cbegin(), instruments.cend(), instrument) == instruments.cend()) {
    instrument = instruments.front();
  }
  return instrument;
}
} // namespace
 
void ISISJournalGetExperimentRuns::init() {
  auto const instruments = getInstruments();
  auto const instrument = getDefaultInstrument(instruments);
 
  declareProperty("Instrument", instrument, std::make_shared<StringListValidator>(instruments), "The instrument name");
  declareProperty("Cycle", "", std::make_shared<MandatoryValidator<std::string>>(), "The cycle name, for example 19_4");
  declareProperty("InvestigationId", "", std::make_shared<MandatoryValidator<std::string>>(),
                  "ID of the selected investigation");
  declareProperty(
      std::make_unique<API::WorkspaceProperty<API::ITableWorkspace>>("OutputWorkspace", "", Kernel::Direction::Output),
      "The name of the workspace to store the run details.");
}
 
void ISISJournalGetExperimentRuns::exec() {
  auto instrument = getPropertyValue("Instrument");
  auto cycle = getPropertyValue("Cycle");
  auto investigationId = getPropertyValue("InvestigationId");
  auto journal = makeJournal(instrument, cycle);
 
  auto runs = getRuns(journal.get(), investigationId);
  auto workspace = convertRunDataToTable(runs);
  setProperty("OutputWorkspace", workspace);
}
 
std::unique_ptr<IJournal> ISISJournalGetExperimentRuns::makeJournal(std::string const &instrument,
                                                                    std::string const &cycle) {
  return std::make_unique<ISISJournal>(instrument, cycle);
}
} // namespace Mantid::DataHandling