DgsRemap.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/DgsRemap.h"
#include "MantidAPI/FileProperty.h"
#include "MantidDataObjects/GroupingWorkspace.h"
 
using namespace Mantid::Kernel;
using namespace Mantid::API;
using namespace Mantid::DataObjects;
 
namespace Mantid::WorkflowAlgorithms {
 
// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(DgsRemap)
 
//----------------------------------------------------------------------------------------------
const std::string DgsRemap::name() const { return "DgsRemap"; }
 
int DgsRemap::version() const { return 1; }
 
const std::string DgsRemap::category() const { return "Workflow\\Inelastic"; }
 
//----------------------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------------------
void DgsRemap::init() {
  this->declareProperty(std::make_unique<WorkspaceProperty<>>("InputWorkspace", "", Direction::Input),
                        "An input workspace to mask and group.");
  this->declareProperty(
      std::make_unique<WorkspaceProperty<>>("MaskWorkspace", "", Direction::Input, PropertyMode::Optional),
      "A workspace containing masking information.");
  this->declareProperty(
      std::make_unique<WorkspaceProperty<>>("GroupingWorkspace", "", Direction::Input, PropertyMode::Optional),
      "A workspace containing grouping information");
  this->declareProperty(std::make_unique<FileProperty>("OldGroupingFile", "", FileProperty::OptionalLoad),
                        "Name of an old grouping format (not XML) file.");
  this->declareProperty("ExecuteOppositeOrder", false, "Execute grouping before masking.");
  this->declareProperty(std::make_unique<WorkspaceProperty<>>("OutputWorkspace", "", Direction::Output),
                        "The resulting workspace.");
}
 
//----------------------------------------------------------------------------------------------
void DgsRemap::exec() {
  MatrixWorkspace_sptr inputWS = this->getProperty("InputWorkspace");
  MatrixWorkspace_sptr outputWS = this->getProperty("OutputWorkspace");
 
  bool runOpposite = this->getProperty("ExecuteOppositeOrder");
  if (!runOpposite) {
    this->execMasking(inputWS);
    this->execGrouping(inputWS, outputWS);
  } else {
    this->execGrouping(inputWS, outputWS);
    this->execMasking(inputWS);
  }
 
  this->setProperty("OutputWorkspace", outputWS);
}
 
void DgsRemap::execMasking(const MatrixWorkspace_sptr &iWS) {
  MatrixWorkspace_sptr maskWS = this->getProperty("MaskWorkspace");
  if (maskWS) {
    auto mask = createChildAlgorithm("MaskDetectors");
    mask->setProperty("Workspace", iWS);
    mask->setProperty("MaskedWorkspace", maskWS);
    mask->executeAsChildAlg();
  }
}
 
void DgsRemap::execGrouping(const MatrixWorkspace_sptr &iWS, MatrixWorkspace_sptr &oWS) {
  MatrixWorkspace_sptr groupWS = this->getProperty("GroupingWorkspace");
  std::string oldGroupingFile = this->getProperty("OldGroupingFile");
  if (groupWS && !oldGroupingFile.empty()) {
    throw std::runtime_error("Choose either GroupingWorkspace or OldGroupingFile property!");
  }
 
  if (groupWS || !oldGroupingFile.empty()) {
    auto group = createChildAlgorithm("GroupDetectors");
    group->setProperty("InputWorkspace", iWS);
    group->setProperty("OutputWorkspace", iWS);
    if (groupWS) {
      int64_t ngroups = 0;
      std::vector<int> groupDetIdList;
      GroupingWorkspace_sptr gWS = std::dynamic_pointer_cast<GroupingWorkspace>(groupWS);
      gWS->makeDetectorIDToGroupVector(groupDetIdList, ngroups);
      group->setProperty("DetectorList", groupDetIdList);
    }
    if (!oldGroupingFile.empty()) {
      group->setProperty("MapFile", oldGroupingFile);
    }
    group->setProperty("Behaviour", "Average");
    group->executeAsChildAlg();
    oWS = group->getProperty("OutputWorkspace");
  }
}
 
} // namespace Mantid::WorkflowAlgorithms