CorelliCalibrationApply.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/CorelliCalibrationApply.h"
#include "MantidAPI/FileProperty.h"
#include "MantidAPI/ITableWorkspace.h"
#include "MantidAPI/InstrumentValidator.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidGeometry/Objects/IObject.h"
#include "MantidKernel/Logger.h"
 
namespace Mantid::Algorithms {
 
using namespace Kernel;
using namespace API;
using namespace DataObjects;
namespace {
Logger logger("CorelliCalibrationApply");
}
 
DECLARE_ALGORITHM(CorelliCalibrationApply)
 
 
void CorelliCalibrationApply::init() {
 
  // InputWorkspace
  // [Input, Required, MatrixWorkspace or EventsWorkspace]
  // workspace to which the calibration should be applied
  auto wsValidator = std::make_shared<InstrumentValidator>();
  declareProperty(std::make_unique<WorkspaceProperty<MatrixWorkspace>>("Workspace", "", Direction::InOut,
                                                                       PropertyMode::Mandatory, wsValidator),
                  "CORELLI workspace to calibrate");
 
  // CalibrationTable
  // [Input, Mandatory, TableWorkspace]
  // workspace resulting from uploading
  declareProperty(std::make_unique<WorkspaceProperty<TableWorkspace>>("CalibrationTable", "", Direction::Input,
                                                                      PropertyMode::Mandatory),
                  "TableWorkspace containing calibration table");
}
 
std::map<std::string, std::string> CorelliCalibrationApply::validateInputs() {
  std::map<std::string, std::string> issues;
  ws = getProperty("Workspace");
 
  // 1_check: input workspace is from CORELLI
  if (ws->getInstrument()->getName() != "CORELLI") {
    issues["Workspace"] = "CORELLI only algorithm, aborting";
  }
 
  // 2_check: headers of calibration table
  calTable = getProperty("CalibrationTable");
  auto refCalTableHeader = CorelliCalibration::calibrationTableColumnNames;
  std::vector<std::string> colnames = calTable->getColumnNames();
  if (colnames.size() != refCalTableHeader.size()) {
    issues["CalibrationTable"] = "Headers of input calibration table does not match required";
  }
  for (size_t i = 0; i < colnames.size(); i++) {
    if (colnames[i] != refCalTableHeader[i]) {
      issues["CalibrationTable"] = "Header mismatch at " + std::to_string(i);
      break;
    }
  }
 
  return issues;
}
 
void CorelliCalibrationApply::exec() {
  g_log.notice() << "Start applying CORELLI calibration\n";
 
  // Parse input arguments
  ws = getProperty("Workspace");
  auto wsName = ws->getName();
 
  calTable = getProperty("CalibrationTable");
  const auto componentNames = calTable->getColumn(0);
  const auto x_poss = calTable->getColumn(1);
  const auto y_poss = calTable->getColumn(2);
  const auto z_poss = calTable->getColumn(3);
  const auto rotxs = calTable->getColumn(4);
  const auto rotys = calTable->getColumn(5);
  const auto rotzs = calTable->getColumn(6);
  const auto rotangs = calTable->getColumn(7); // unit: degrees
 
  g_log.notice() << "Translating each component using given Calibration table";
  auto moveAlg = createChildAlgorithm("MoveInstrumentComponent");
  moveAlg->initialize();
  moveAlg->setProperty("Workspace", wsName);
  for (size_t row_num = 0; row_num < calTable->rowCount(); row_num++) {
    moveAlg->setProperty("ComponentName", componentNames->cell<std::string>(row_num));
    moveAlg->setProperty("X", x_poss->cell<double>(row_num));
    moveAlg->setProperty("Y", y_poss->cell<double>(row_num));
    moveAlg->setProperty("Z", z_poss->cell<double>(row_num));
    // [IMPORTANT]
    // The position data from calibration table are ABSOLUTE values (lab frame)
    moveAlg->setProperty("RelativePosition", false);
    moveAlg->execute();
  }
 
  g_log.notice() << "Rotating each component using given Calibration table";
  auto rotateAlg = createChildAlgorithm("RotateInstrumentComponent");
  rotateAlg->initialize();
  rotateAlg->setProperty("Workspace", wsName);
  for (size_t row_num = 0; row_num < calTable->rowCount(); row_num++) {
    if (std::abs(rotangs->cell<double>(row_num)) < 1e-8) {
      continue;
    }
    rotateAlg->setProperty("ComponentName", componentNames->cell<std::string>(row_num));
    rotateAlg->setProperty("X", rotxs->cell<double>(row_num));
    rotateAlg->setProperty("Y", rotys->cell<double>(row_num));
    rotateAlg->setProperty("Z", rotzs->cell<double>(row_num));
    rotateAlg->setProperty("Angle", rotangs->cell<double>(row_num));
    // [IMPORTANT]
    // The rotation required here has to be the RELATIVE rotation angle in
    // degrees
    rotateAlg->setProperty("RelativeRotation", false);
    rotateAlg->execute();
  }
 
  // Config output
  setProperty("Workspace", ws);
 
  g_log.notice() << "Finished applying CORELLI calibration\n";
}
 
} // namespace Mantid::Algorithms