CreateTransmissionWorkspaceAuto.cpp

/*WIKI*
 Facade over [[CreateTransmissionWorkspace]]. Pull numeric parameters out of the
 instrument parameters where possible. You can override any of these
 automatically
 applied defaults by providing your own value for the input.

 See [[CreateTransmissionWorkspace]] for more information on the wrapped
 algorithm.
 *WIKI*/

#include "MantidAlgorithms/CreateTransmissionWorkspaceAuto.h"
#include "MantidKernel/RebinParamsValidator.h"
#include "MantidAPI/WorkspaceValidators.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/ArrayProperty.h"
#include "MantidKernel/BoundedValidator.h"
#include "MantidAPI/AlgorithmManager.h"

using namespace Mantid::Kernel;
using namespace Mantid::API;

namespace Mantid {
namespace Algorithms {

// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(CreateTransmissionWorkspaceAuto)

//----------------------------------------------------------------------------------------------
/** Constructor
 */
CreateTransmissionWorkspaceAuto::CreateTransmissionWorkspaceAuto() {}

//----------------------------------------------------------------------------------------------
/** Destructor
 */
CreateTransmissionWorkspaceAuto::~CreateTransmissionWorkspaceAuto() {}

//----------------------------------------------------------------------------------------------
/// Sets documentation strings for this algorithm
const std::string CreateTransmissionWorkspaceAuto::summary() const {
  return "Creates a transmission run workspace in Wavelength from input TOF "
         "workspaces.";
}

//----------------------------------------------------------------------------------------------
/** Initialize the algorithm's properties.
 */
void CreateTransmissionWorkspaceAuto::init() {

  std::vector<std::string> analysis_modes;
  analysis_modes.push_back("PointDetectorAnalysis");
  analysis_modes.push_back("MultiDetectorAnalysis");
  declareProperty("AnalysisMode", analysis_modes.at(0),
                  boost::make_shared<StringListValidator>(analysis_modes),
                  "Analysis Mode to Choose", Direction::Input);

  declareProperty(new WorkspaceProperty<MatrixWorkspace>(
                      "FirstTransmissionRun", "", Direction::Input,
                      boost::make_shared<WorkspaceUnitValidator>("TOF")),
                  "Input workspace.");
  declareProperty(new WorkspaceProperty<MatrixWorkspace>(
                      "SecondTransmissionRun", "", Direction::Input,
                      PropertyMode::Optional,
                      boost::make_shared<WorkspaceUnitValidator>("TOF")),
                  "Second transmission run workspace in TOF.");
  declareProperty(new WorkspaceProperty<MatrixWorkspace>("OutputWorkspace", "",
                                                         Direction::Output),
                  "Output transmission workspace in wavelength.");

  declareProperty(
      new ArrayProperty<double>("Params",
                                boost::make_shared<RebinParamsValidator>(true)),
      "A comma separated list of first bin boundary, width, last bin boundary. "
      "These parameters are used for stitching together transmission runs. "
      "Values are in wavelength (angstroms). This input is only needed if a "
      "SecondTransmission run is provided.");

  declareProperty(new PropertyWithValue<double>(
                      "StartOverlap", Mantid::EMPTY_DBL(), Direction::Input),
                  "Start wavelength for stitching transmission runs together");

  declareProperty(
      new PropertyWithValue<double>("EndOverlap", Mantid::EMPTY_DBL(),
                                    Direction::Input),
      "End wavelength (angstroms) for stitching transmission runs together");

  auto boundedIndex = boost::make_shared<BoundedValidator<int>>();
  boundedIndex->setLower(0);

  declareProperty(new PropertyWithValue<int>("I0MonitorIndex",
                                             Mantid::EMPTY_INT(), boundedIndex),
                  "I0 monitor index");

  declareProperty(new PropertyWithValue<std::string>("ProcessingInstructions",
                                                     "", Direction::Input),
                  "Grouping pattern on workspace indexes to yield only "
                  "the detectors of interest. See GroupDetectors for details.");

  declareProperty("WavelengthMin", Mantid::EMPTY_DBL(),
                  "Wavelength Min in angstroms", Direction::Input);
  declareProperty("WavelengthMax", Mantid::EMPTY_DBL(),
                  "Wavelength Max in angstroms", Direction::Input);
  declareProperty("WavelengthStep", Mantid::EMPTY_DBL(),
                  "Wavelength step in angstroms", Direction::Input);
  declareProperty("MonitorBackgroundWavelengthMin", Mantid::EMPTY_DBL(),
                  "Monitor wavelength background min in angstroms",
                  Direction::Input);
  declareProperty("MonitorBackgroundWavelengthMax", Mantid::EMPTY_DBL(),
                  "Monitor wavelength background max in angstroms",
                  Direction::Input);
  declareProperty("MonitorIntegrationWavelengthMin", Mantid::EMPTY_DBL(),
                  "Monitor integral min in angstroms", Direction::Input);
  declareProperty("MonitorIntegrationWavelengthMax", Mantid::EMPTY_DBL(),
                  "Monitor integral max in angstroms", Direction::Input);
}

//----------------------------------------------------------------------------------------------
/** Execute the algorithm.
 */
void CreateTransmissionWorkspaceAuto::exec() {
  // auto firstWS =
  // AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(this->getPointerToProperty("FirstTransmissionRun")->value());
  MatrixWorkspace_sptr firstWS = this->getProperty("FirstTransmissionRun");
  auto instrument = firstWS->getInstrument();

  // Get all the inputs.

  std::string outputWorkspaceName = this->getPropertyValue("OutputWorkspace");
  std::string analysis_mode = this->getPropertyValue("AnalysisMode");

  MatrixWorkspace_sptr secondWS = this->getProperty("SecondTransmissionRun");

  auto start_overlap = isSet<double>("StartOverlap");
  auto end_overlap = isSet<double>("EndOverlap");
  auto params = isSet<std::vector<double>>("Params");
  auto i0_monitor_index = static_cast<int>(
      checkForDefault("I0MonitorIndex", instrument, "I0MonitorIndex"));

  std::string processing_commands;
  if (this->getPointerToProperty("ProcessingInstructions")->isDefault()) {
    const int start = static_cast<int>(
        instrument->getNumberParameter("PointDetectorStart")[0]);
    const int stop = static_cast<int>(
        instrument->getNumberParameter("PointDetectorStop")[0]);
    if (analysis_mode == "PointDetectorAnalysis") {
      if (start == stop) {
        processing_commands = boost::lexical_cast<std::string>(start);
      } else {
        processing_commands = boost::lexical_cast<std::string>(start) + "," +
                              boost::lexical_cast<std::string>(stop);
      }
    } else {
      processing_commands =
          boost::lexical_cast<std::string>(static_cast<int>(
              instrument->getNumberParameter("MultiDetectorStart")[0])) +
          "," +
          boost::lexical_cast<std::string>(firstWS->getNumberHistograms() - 1);
    }
  } else {
    std::string processing_commands_temp =
        this->getProperty("ProcessingInstructions");
    processing_commands = processing_commands_temp;
  }

  double wavelength_min =
      checkForDefault("WavelengthMin", instrument, "LambdaMin");
  double wavelength_max =
      checkForDefault("WavelengthMax", instrument, "LambdaMax");
  auto wavelength_step = isSet<double>("WavelengthStep");
  double wavelength_back_min = checkForDefault(
      "MonitorBackgroundWavelengthMin", instrument, "MonitorBackgroundMin");
  double wavelength_back_max = checkForDefault(
      "MonitorBackgroundWavelengthMax", instrument, "MonitorBackgroundMax");
  double wavelength_integration_min = checkForDefault(
      "MonitorIntegrationWavelengthMin", instrument, "MonitorIntegralMin");
  double wavelength_integration_max = checkForDefault(
      "MonitorIntegrationWavelengthMax", instrument, "MonitorIntegralMax");

  // construct the algorithm

  IAlgorithm_sptr algCreateTransWS =
      createChildAlgorithm("CreateTransmissionWorkspace");
  algCreateTransWS->setRethrows(true);
  algCreateTransWS->initialize();

  if (algCreateTransWS->isInitialized()) {

    algCreateTransWS->setProperty("FirstTransmissionRun", firstWS);

    if (secondWS) {
      algCreateTransWS->setProperty("SecondTransmissionRun", secondWS);
    }

    algCreateTransWS->setProperty("OutputWorkspace", outputWorkspaceName);

    if (start_overlap.is_initialized()) {
      algCreateTransWS->setProperty("StartOverlap", start_overlap.get());
    }
    if (end_overlap.is_initialized()) {
      algCreateTransWS->setProperty("EndOverlap", end_overlap.get());
    }
    if (params.is_initialized()) {
      algCreateTransWS->setProperty("Params", params.get());
    }

    algCreateTransWS->setProperty("I0MonitorIndex", i0_monitor_index);
    algCreateTransWS->setProperty("ProcessingInstructions",
                                  processing_commands);
    algCreateTransWS->setProperty("WavelengthMin", wavelength_min);

    if (wavelength_step.is_initialized()) {
      algCreateTransWS->setProperty("WavelengthStep", wavelength_step.get());
    }

    algCreateTransWS->setProperty("WavelengthMax", wavelength_max);
    algCreateTransWS->setProperty("MonitorBackgroundWavelengthMin",
                                  wavelength_back_min);
    algCreateTransWS->setProperty("MonitorBackgroundWavelengthMax",
                                  wavelength_back_max);
    algCreateTransWS->setProperty("MonitorIntegrationWavelengthMin",
                                  wavelength_integration_min);
    algCreateTransWS->setProperty("MonitorIntegrationWavelengthMax",
                                  wavelength_integration_max);

    algCreateTransWS->execute();
    if (!algCreateTransWS->isExecuted()) {
      throw std::runtime_error(
          "CreateTransmissionWorkspace did not execute sucessfully");
    } else {
      MatrixWorkspace_sptr outWS =
          algCreateTransWS->getProperty("OutputWorkspace");
      setProperty("OutputWorkspace", outWS);
    }
  } else {
    throw std::runtime_error(
        "CreateTransmissionWorkspace could not be initialised");
  }
}

template <typename T>
boost::optional<T>
CreateTransmissionWorkspaceAuto::isSet(std::string propName) const {
  auto algProperty = this->getPointerToProperty(propName);
  if (algProperty->isDefault()) {
    return boost::optional<T>();
  } else {
    T value = this->getProperty(propName);
    return boost::optional<T>(value);
  }
}

double CreateTransmissionWorkspaceAuto::checkForDefault(
    std::string propName, Mantid::Geometry::Instrument_const_sptr instrument,
    std::string idf_name) const {
  auto algProperty = this->getPointerToProperty(propName);
  if (algProperty->isDefault()) {
    auto defaults = instrument->getNumberParameter(idf_name);
    if (defaults.size() == 0) {
      throw std::runtime_error("No data could be retrieved from the parameters "
                               "and argument wasn't provided: " +
                               propName);
    }
    return defaults[0];
  } else {
    return boost::lexical_cast<double, std::string>(algProperty->value());
  }
}

} // namespace Algorithms
} // namespace Mantid