StepScan.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 "MantidWorkflowAlgorithms/StepScan.h"
#include "MantidAPI/ITableWorkspace.h"
#include "MantidAPI/WorkspaceUnitValidator.h"
#include "MantidKernel/DynamicPointerCastHelper.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/UnitFactory.h"
 
namespace Mantid::WorkflowAlgorithms {
// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(StepScan)
 
using namespace Kernel;
using namespace API;
 
const std::string StepScan::name() const { return "StepScan"; }
 
int StepScan::version() const { return 1; }
 
const std::string StepScan::category() const { return "Workflow\\Alignment"; }
 
void StepScan::init() {
  // TODO: Validator to ensure that this is 'fresh' data???
  declareProperty(std::make_unique<WorkspaceProperty<DataObjects::EventWorkspace>>(
                      "InputWorkspace", "", Direction::Input, std::make_shared<WorkspaceUnitValidator>("TOF")),
                  "The input workspace. Must hold 'raw' (unweighted) events.");
  // Note that this algorithm may modify the input workspace (by masking and/or
  // cropping)
  declareProperty(std::make_unique<WorkspaceProperty<ITableWorkspace>>("OutputWorkspace", "", Direction::Output),
                  "The output table workspace.");
 
  declareProperty(std::make_unique<WorkspaceProperty<MatrixWorkspace>>("MaskWorkspace", "", Direction::Input,
                                                                       PropertyMode::Optional),
                  "A workspace holding pixels to be masked.");
 
  declareProperty("XMin", EMPTY_DBL(), "The minimum value of X for which an event will be counted.");
  declareProperty("XMax", EMPTY_DBL(),
                  "The maximum value of X for which an "
                  "event will be counted. Must be greater "
                  "than XMin.");
  // N.B. The choice of units is restricted by the upstream StepScan interface,
  // but in fact any convertible unit will work so is allowed here
  declareProperty("RangeUnit", "TOF", std::make_shared<StringListValidator>(UnitFactory::Instance().getKeys()),
                  "The units in which XMin and XMax is being given.");
}
 
void StepScan::exec() {
  using DataObjects::EventWorkspace_sptr;
  // Get hold of the input workspace
  EventWorkspace_sptr inputWorkspace = getProperty("InputWorkspace");
  // Get hold of the related monitors workspace, if it exists
  EventWorkspace_sptr monitorWorkspace = getMonitorWorkspace(inputWorkspace);
 
  // If any of the filtering properties have been set, clone the input workspace
  MatrixWorkspace_sptr maskWS = getProperty("MaskWorkspace");
  const double xmin = getProperty("XMin");
  const double xmax = getProperty("XMax");
  if (maskWS || !isEmpty(xmin) || !isEmpty(xmax)) {
    inputWorkspace = cloneInputWorkspace(inputWorkspace);
  }
 
  // If the MaskWorkspace property has been set, run the MaskDetectors algorithm
  if (maskWS) {
    runMaskDetectors(inputWorkspace, maskWS);
  }
 
  // If a restricted X range has been set, handle that
  if (!isEmpty(xmin) || !isEmpty(xmax)) {
    runFilterByXValue(inputWorkspace, xmin, xmax);
    // TODO: In what circumstances should we filter the monitors???
    // if ( monitorWorkspace ) runFilterByXValue(monitorWorkspace, xmin, xmax);
  }
 
  // Run the SumEventsByLogValue algorithm with the log fixed to 'scan_index'
  auto sumEvents = createChildAlgorithm("SumEventsByLogValue");
  sumEvents->setProperty<EventWorkspace_sptr>("InputWorkspace", inputWorkspace);
  if (monitorWorkspace) {
    sumEvents->setProperty<EventWorkspace_sptr>("MonitorWorkspace", monitorWorkspace);
  }
  sumEvents->setProperty("LogName", "scan_index");
  sumEvents->executeAsChildAlg();
 
  Workspace_sptr outputWS = sumEvents->getProperty("OutputWorkspace");
  auto table = Kernel::DynamicPointerCastHelper::dynamicPointerCastWithCheck<ITableWorkspace, API::Workspace>(
      std::move(outputWS));
  // Remove the scan_index=0 entry from the resulting table (unless it's the
  // only one)
  if (table->rowCount() > 1 && table->Int(0, 0) == 0) {
    table->removeRow(0);
  }
 
  setProperty("OutputWorkspace", table);
}
 
DataObjects::EventWorkspace_sptr StepScan::getMonitorWorkspace(const API::MatrixWorkspace_sptr &inputWS) {
  // See if there's a monitor workspace inside the input one
  return std::dynamic_pointer_cast<DataObjects::EventWorkspace>(inputWS->monitorWorkspace());
}
 
DataObjects::EventWorkspace_sptr StepScan::cloneInputWorkspace(const API::Workspace_sptr &inputWS) {
  auto clone = createChildAlgorithm("CloneWorkspace");
  clone->setProperty("InputWorkspace", inputWS);
  clone->executeAsChildAlg();
 
  Workspace_sptr temp = clone->getProperty("OutputWorkspace");
  return std::static_pointer_cast<DataObjects::EventWorkspace>(temp);
}
 
void StepScan::runMaskDetectors(const MatrixWorkspace_sptr &inputWS, const MatrixWorkspace_sptr &maskWS) {
  auto maskingAlg = createChildAlgorithm("MaskDetectors");
  maskingAlg->setProperty<MatrixWorkspace_sptr>("Workspace", inputWS);
  maskingAlg->setProperty<MatrixWorkspace_sptr>("MaskedWorkspace", maskWS);
  maskingAlg->executeAsChildAlg();
}
 
void StepScan::runFilterByXValue(const MatrixWorkspace_sptr &inputWS, const double xmin, const double xmax) {
  std::string rangeUnit = getProperty("RangeUnit");
  // Run ConvertUnits on the input workspace if xmin/max were given in a
  // different unit
  if (rangeUnit != "TOF") {
    auto convertUnits = createChildAlgorithm("ConvertUnits");
    convertUnits->setProperty<MatrixWorkspace_sptr>("InputWorkspace", inputWS);
    convertUnits->setProperty<MatrixWorkspace_sptr>("OutputWorkspace", inputWS);
    convertUnits->setProperty("Target", rangeUnit);
    // TODO: Emode/efixed?
    convertUnits->executeAsChildAlg();
  }
 
  auto filter = createChildAlgorithm("FilterByXValue");
  filter->setProperty<MatrixWorkspace_sptr>("InputWorkspace", inputWS);
  filter->setProperty<MatrixWorkspace_sptr>("OutputWorkspace", inputWS);
  filter->setProperty("XMin", xmin);
  filter->setProperty("XMax", xmax);
  filter->executeAsChildAlg();
}
 
} // namespace Mantid::WorkflowAlgorithms