ResizeRectangularDetector.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/ResizeRectangularDetector.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/ResizeRectangularDetectorHelper.h"
#include "MantidAPI/WorkspaceProperty.h"
#include "MantidDataObjects/PeaksWorkspace.h"
#include "MantidGeometry/IComponent.h"
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
 
using namespace Mantid::Kernel;
using namespace Mantid::API;
using namespace Mantid::Geometry;
 
namespace Mantid::Algorithms {
 
// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(ResizeRectangularDetector)
 
//----------------------------------------------------------------------------------------------
const std::string ResizeRectangularDetector::name() const { return "ResizeRectangularDetector"; }
 
int ResizeRectangularDetector::version() const { return 1; }
 
const std::string ResizeRectangularDetector::category() const { return "DataHandling\\Instrument"; }
 
//----------------------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------------------
void ResizeRectangularDetector::init() {
  // When used as a Child Algorithm the workspace name is not used - hence the
  // "Anonymous" to satisfy the validator
  declareProperty(std::make_unique<WorkspaceProperty<Workspace>>("Workspace", "Anonymous", Direction::InOut));
  declareProperty("ComponentName", "", "The name of the RectangularDetector to resize.");
  declareProperty("ScaleX", 1.0, "The scaling factor in the X direction. Default 1.0");
  declareProperty("ScaleY", 1.0, "The scaling factor in the Y direction. Default 1.0");
}
 
//----------------------------------------------------------------------------------------------
void ResizeRectangularDetector::exec() {
  // Get the input workspace
  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 and it does not seem to be valid as "
                             "input (must be either MatrixWorkspace or "
                             "PeaksWorkspace");
  }
 
  std::string ComponentName = getPropertyValue("ComponentName");
  double ScaleX = getProperty("ScaleX");
  double ScaleY = getProperty("ScaleY");
 
  if (ComponentName.empty())
    throw std::runtime_error("You must specify a ComponentName.");
 
  auto input = std::dynamic_pointer_cast<ExperimentInfo>(ws);
  auto &componentInfo = input->mutableComponentInfo();
 
  size_t componentIndex;
  try {
    componentIndex = componentInfo.indexOfAny(ComponentName);
  } catch (std::invalid_argument &) {
    throw std::runtime_error("Component with name " + ComponentName + " was not found.");
  }
  if (!componentInfo.isGridDetector(componentIndex)) {
    throw std::runtime_error("Component with name " + ComponentName + " is not a RectangularDetector.");
  }
  Geometry::ParameterMap &pmap = input->instrumentParameters();
  const std::string &resolvedName = componentInfo.name(componentIndex);
  auto oldscalex = pmap.getDouble(resolvedName, std::string("scalex"));
  auto oldscaley = pmap.getDouble(resolvedName, std::string("scaley"));
  // Add a parameter for the new scale factors
  auto *componentID = const_cast<IComponent *>(componentInfo.componentID(componentIndex));
  pmap.addDouble(componentID, "scalex", ScaleX);
  pmap.addDouble(componentID, "scaley", ScaleY);
  pmap.clearPositionSensitiveCaches();
 
  // Positions of detectors are now stored in DetectorInfo, so we must update
  // positions there.
  // This algorithm is setting the absolute scale factor. Since there may be a
  // previous scaling we have to factor that out.
  double relscalex = ScaleX;
  double relscaley = ScaleY;
  if (!oldscalex.empty())
    relscalex /= oldscalex[0];
  if (!oldscaley.empty())
    relscaley /= oldscaley[0];
  applyRectangularDetectorScaleToComponentInfo(componentInfo, componentID, relscalex, relscaley);
}
 
} // namespace Mantid::Algorithms