SetInstrumentParameter.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 "MantidAlgorithms/SetInstrumentParameter.h"
#include "MantidAPI/InstrumentValidator.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidDataObjects/PeaksWorkspace.h"
#include "MantidGeometry/Instrument.h"
#include "MantidKernel/ArrayProperty.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/MandatoryValidator.h"
#include "MantidKernel/Strings.h"
 
#include <boost/algorithm/string.hpp>
 
namespace Mantid::Algorithms {
 
// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(SetInstrumentParameter)
 
using namespace Kernel;
using namespace Geometry;
using namespace API;
 
//----------------------------------------------------------------------------------------------
const std::string SetInstrumentParameter::name() const { return "SetInstrumentParameter"; }
 
int SetInstrumentParameter::version() const { return 1; }
 
const std::string SetInstrumentParameter::category() const { return "DataHandling\\Instrument"; }
 
//----------------------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------------------
void SetInstrumentParameter::init() {
  declareProperty(std::make_unique<WorkspaceProperty<Workspace>>("Workspace", "", Direction::InOut,
                                                                 std::make_shared<InstrumentValidator>()),
                  "Workspace to add the log entry to");
  declareProperty("ComponentName", "",
                  "The name of the component to attach "
                  "the parameter to. Default: the whole "
                  "instrument");
  declareProperty(std::make_unique<ArrayProperty<detid_t>>("DetectorList"),
                  "The detector ID list to attach the parameter to. If set "
                  "this will override any ComponentName");
  declareProperty("ParameterName", "", std::make_shared<MandatoryValidator<std::string>>(),
                  "The name that will identify the parameter");
 
  std::vector<std::string> propOptions{"String", "Number", "Bool"};
  declareProperty("ParameterType", "String", std::make_shared<StringListValidator>(propOptions),
                  "The type that the parameter value will be.");
 
  declareProperty("Value", "", "The content of the Parameter");
}
 
std::map<std::string, std::string> SetInstrumentParameter::validateInputs() {
  std::map<std::string, std::string> errors;
  const std::set<std::string> allowedBoolValues{"1", "0", "true", "false"};
  const std::string type = getPropertyValue("ParameterType");
  std::string val = getPropertyValue("Value");
 
  if (type == "Bool") {
    boost::algorithm::to_lower(val);
    if (allowedBoolValues.find(val) == allowedBoolValues.end()) {
      errors["Value"] = "Invalid value for Bool type.";
    }
  } else if (type == "Number") {
    int intVal;
    double dblVal;
    if (!Strings::convert(val, intVal) && !Strings::convert(val, dblVal)) {
      errors["Value"] = "Invalid value for Number type.";
    }
  }
 
  return errors;
}
 
//----------------------------------------------------------------------------------------------
void SetInstrumentParameter::exec() {
  // A pointer to the workspace to add a log to
  Workspace_sptr ws = getProperty("Workspace");
  MatrixWorkspace_sptr inputW = std::dynamic_pointer_cast<MatrixWorkspace>(ws);
  DataObjects::PeaksWorkspace_sptr inputP = std::dynamic_pointer_cast<DataObjects::PeaksWorkspace>(ws);
  // Get some stuff from the input workspace
  Instrument_sptr inst;
  if (inputW) {
    inst = std::const_pointer_cast<Instrument>(inputW->getInstrument());
    if (!inst)
      throw std::runtime_error("Could not get a valid instrument from the "
                               "MatrixWorkspace provided as input");
  } else if (inputP) {
    inst = std::const_pointer_cast<Instrument>(inputP->getInstrument());
    if (!inst)
      throw std::runtime_error("Could not get a valid instrument from the "
                               "PeaksWorkspace provided as input");
  } else {
    throw std::runtime_error("Could not get a valid instrument from the "
                             "workspace which does not seem to be valid as "
                             "input (must be either MatrixWorkspace or "
                             "PeaksWorkspace");
  }
 
  // get the data that the user wants to add
  std::string cmptName = getProperty("ComponentName");
  const std::vector<detid_t> detectorList = getProperty("DetectorList");
  std::string paramName = getProperty("ParameterName");
  std::string paramType = getProperty("ParameterType");
  std::string paramValue = getPropertyValue("Value");
 
  Strings::strip(cmptName);
  Strings::strip(paramName);
  Strings::strip(paramValue);
 
  std::vector<IDetector_const_sptr> dets;
  std::vector<IComponent_const_sptr> cmptList;
  // set default to whole instrument
  cmptList.emplace_back(inst);
 
  if (!detectorList.empty()) {
    dets = inst->getDetectors(detectorList);
  } else if (cmptName.length() > 0) {
    // get all matching cmpts
    cmptList = inst->getAllComponentsWithName(cmptName);
  }
 
  if (inputW) {
    auto &paramMap = inputW->instrumentParameters();
    if (!dets.empty()) {
      for (auto &det : dets) {
        addParameter(paramMap, det.get(), paramName, paramType, paramValue);
      }
    } else {
      if (!cmptList.empty()) {
        for (auto &cmpt : cmptList) {
          addParameter(paramMap, cmpt.get(), paramName, paramType, paramValue);
        }
      } else {
        g_log.warning("Could not find the component requested.");
      }
    }
  }
  if (inputP) {
    auto &paramMap = inputP->instrumentParameters();
    if (!dets.empty()) {
      for (auto &det : dets) {
        addParameter(paramMap, det.get(), paramName, paramType, paramValue);
      }
    } else {
      if (!cmptList.empty()) {
        for (auto &cmpt : cmptList) {
          addParameter(paramMap, cmpt.get(), paramName, paramType, paramValue);
        }
      } else {
        g_log.warning("Could not find the component requested.");
      }
    }
  }
}
 
void SetInstrumentParameter::addParameter(Mantid::Geometry::ParameterMap &pmap,
                                          const Mantid::Geometry::IComponent *cmptId, const std::string &paramName,
                                          const std::string &paramType, const std::string &paramValue) const {
 
  // remove existing parameters first
  pmap.clearParametersByName(paramName, cmptId);
  // then add the new one
  if (paramType == "String") {
    pmap.addString(cmptId, paramName, paramValue);
  } else if (paramType == "Number") {
    int intVal;
    if (Strings::convert(paramValue, intVal)) {
      pmap.addInt(cmptId, paramName, intVal);
    } else {
      double dblVal;
      Strings::convert(paramValue, dblVal);
      pmap.addDouble(cmptId, paramName, dblVal);
    }
  } else if (paramType == "Bool") {
    std::string paramValueLower(paramValue);
    boost::algorithm::to_lower(paramValueLower);
    bool paramBoolValue = (paramValueLower == "true" || paramValue == "1");
    pmap.addBool(cmptId, paramName, paramBoolValue);
  }
}
 
} // namespace Mantid::Algorithms