ThresholdMD.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 "MantidMDAlgorithms/ThresholdMD.h"
#include "MantidAPI/Progress.h"
#include "MantidAPI/WorkspaceProperty.h"
#include "MantidDataObjects/MDHistoWorkspace.h"
#include "MantidKernel/EnabledWhenProperty.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/MultiThreaded.h"
#include <boost/function.hpp>
 
using namespace Mantid::Kernel;
using namespace Mantid::API;
using namespace Mantid::DataObjects;
 
namespace Mantid::MDAlgorithms {
 
// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(ThresholdMD)
 
std::string LessThan() { return "Less Than"; }
 
std::string GreaterThan() { return "Greater Than"; }
 
//----------------------------------------------------------------------------------------------
const std::string ThresholdMD::name() const { return "ThresholdMD"; }
 
int ThresholdMD::version() const { return 1; }
 
const std::string ThresholdMD::category() const { return "MDAlgorithms\\Transforms"; }
 
//----------------------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------------------
void ThresholdMD::init() {
  declareProperty(std::make_unique<WorkspaceProperty<IMDHistoWorkspace>>("InputWorkspace", "", Direction::Input),
                  "An input workspace.");
 
  std::vector<std::string> propOptions;
  propOptions.emplace_back(LessThan());
  propOptions.emplace_back(GreaterThan());
 
  declareProperty("Condition", LessThan(), std::make_shared<StringListValidator>(propOptions),
                  "Selected threshold condition. Any value which does meet "
                  "this condition with respect to the ReferenceValue will be "
                  "overwritten.");
 
  declareProperty("ReferenceValue", 0.0, "Comparator value used by the Condition.");
 
  declareProperty("OverwriteWithZero", true,
                  "Flag for enabling overwriting "
                  "with a custom value. Defaults to "
                  "overwrite signals with zeros.");
 
  declareProperty("CustomOverwriteValue", 0.0, "Custom overwrite value for the signal. Defaults to zero.");
  setPropertySettings("CustomOverwriteValue",
                      std::make_unique<EnabledWhenProperty>("OverwriteWithZero", IS_NOT_DEFAULT));
 
  declareProperty(std::make_unique<WorkspaceProperty<IMDHistoWorkspace>>("OutputWorkspace", "", Direction::Output),
                  "Output thresholded workspace.");
}
 
//----------------------------------------------------------------------------------------------
void ThresholdMD::exec() {
  IMDHistoWorkspace_sptr inputWS = getProperty("InputWorkspace");
  const std::string condition = getProperty("Condition");
  const double referenceValue = getProperty("ReferenceValue");
  const bool doOverwriteWithZero = getProperty("OverwriteWithZero");
  double customOverwriteValue = getProperty("CustomOverwriteValue");
  if (doOverwriteWithZero) {
    customOverwriteValue = 0;
  }
 
  IMDHistoWorkspace_sptr outWS = getProperty("OutputWorkspace");
  if (outWS != inputWS) {
    g_log.debug("Deep copy input workspace as output workspace.");
    auto alg = createChildAlgorithm("CloneMDWorkspace");
    alg->setProperty("InputWorkspace", inputWS);
    alg->executeAsChildAlg();
    IMDWorkspace_sptr temp = alg->getProperty("OutputWorkspace");
    outWS = std::dynamic_pointer_cast<IMDHistoWorkspace>(temp);
  }
 
  const int64_t nPoints = inputWS->getNPoints();
 
  using namespace std::placeholders;
  boost::function<bool(double)> comparitor = std::bind(std::less<double>(), std::placeholders::_1, referenceValue);
  if (condition == GreaterThan()) {
    comparitor = std::bind(std::greater<double>(), std::placeholders::_1, referenceValue);
  }
 
  Progress prog(this, 0.0, 1.0, 100);
  int64_t frequency = nPoints;
  if (nPoints > 100) {
    frequency = nPoints / 100;
  }
 
  PARALLEL_FOR_IF(Kernel::threadSafe(*inputWS, *outWS))
  for (int64_t i = 0; i < nPoints; ++i) {
    PARALLEL_START_INTERRUPT_REGION
    const double signalAt = inputWS->getSignalAt(i);
    if (comparitor(signalAt)) {
      outWS->setSignalAt(i, customOverwriteValue);
    }
    if (i % frequency == 0) {
      prog.report();
    }
    PARALLEL_END_INTERRUPT_REGION
  }
  PARALLEL_CHECK_INTERRUPT_REGION
 
  setProperty("OutputWorkspace", outWS);
}
 
} // namespace Mantid::MDAlgorithms