LoadIsawDetCal.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 "MantidDataHandling/LoadIsawDetCal.h"
 
#include "MantidAPI/FileProperty.h"
#include "MantidAPI/InstrumentValidator.h"
#include "MantidAPI/MultipleFileProperty.h"
#include "MantidAPI/Run.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
 
#include "MantidDataObjects/EventList.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/PeaksWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
 
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/ObjCompAssembly.h"
 
#include "MantidKernel/Strings.h"
#include "MantidKernel/V3D.h"
 
#include <algorithm>
#include <boost/algorithm/string/trim.hpp>
#include <fstream>
#include <numeric>
#include <sstream>
#include <utility>
 
namespace Mantid::DataHandling {
 
// Register the class into the algorithm factory
DECLARE_ALGORITHM(LoadIsawDetCal)
 
using namespace Kernel;
using namespace API;
using namespace Geometry;
using namespace DataObjects;
 
void LoadIsawDetCal::init() {
  declareProperty(std::make_unique<WorkspaceProperty<Workspace>>("InputWorkspace", "", Direction::InOut,
                                                                 std::make_shared<InstrumentValidator>()),
                  "The workspace containing the geometry to be calibrated.");
 
  const auto exts = std::vector<std::string>({".DetCal", ".detcal", ".peaks", ".integrate"});
  declareProperty(std::make_unique<API::MultipleFileProperty>("Filename", exts),
                  "The input filename of the ISAW DetCal file (Two files "
                  "allowed for SNAP) ");
 
  declareProperty(std::make_unique<API::FileProperty>("Filename2", "", API::FileProperty::OptionalLoad, exts),
                  "The input filename of the second ISAW DetCal file (West "
                  "banks for SNAP) ");
 
  declareProperty("TimeOffset", 0.0, "Time Offset", Direction::Output);
}
 
namespace {
const constexpr double DegreesPerRadian = 180.0 / M_PI;
 
std::string getBankName(const std::string &bankPart, const int idnum) {
  if (bankPart == "WISHpanel" && idnum < 10) {
    return bankPart + "0" + std::to_string(idnum);
  } else {
    return bankPart + std::to_string(idnum);
  }
}
 
std::string getInstName(const API::Workspace_const_sptr &wksp) {
  MatrixWorkspace_const_sptr matrixWksp = std::dynamic_pointer_cast<const MatrixWorkspace>(wksp);
  if (matrixWksp) {
    return matrixWksp->getInstrumentName();
  }
 
  PeaksWorkspace_const_sptr peaksWksp = std::dynamic_pointer_cast<const PeaksWorkspace>(wksp);
  if (peaksWksp) {
    return peaksWksp->getInstrumentName();
  }
 
  throw std::runtime_error("Failed to determine instrument name");
}
} // namespace
 
std::map<std::string, std::string> LoadIsawDetCal::validateInputs() {
  std::map<std::string, std::string> result;
 
  // two detcal files is only valid for snap
  std::vector<std::string> filenames = getFilenames();
  if (filenames.empty()) {
    result["Filename"] = "Must supply .detcal file";
  } else if (filenames.size() == 2) {
    Workspace_const_sptr wksp = getProperty("InputWorkspace");
    const auto instname = getInstName(wksp);
 
    if (instname != "SNAP") {
      result["Filename"] = "Two files is only valid for SNAP";
    }
  } else if (filenames.size() > 2) {
    result["Filename"] = "Supply at most two .detcal files";
  }
 
  return result;
}
 
void LoadIsawDetCal::exec() {
  // Get the input workspace
  Workspace_sptr ws = getProperty("InputWorkspace");
  MatrixWorkspace_sptr inputW = std::dynamic_pointer_cast<MatrixWorkspace>(ws);
  PeaksWorkspace_sptr inputP = std::dynamic_pointer_cast<PeaksWorkspace>(ws);
 
  Instrument_sptr inst = getCheckInst(ws);
 
  std::string instname = inst->getName();
 
  auto expInfoWS = std::dynamic_pointer_cast<ExperimentInfo>(ws);
  auto &componentInfo = expInfoWS->mutableComponentInfo();
 
  const auto filenames = getFilenames();
 
  // Output summary to log file
  int count, id, nrows, ncols;
  double width, height, depth, detd, x, y, z, base_x, base_y, base_z, up_x, up_y, up_z;
  std::ifstream input(filenames[0].c_str(), std::ios_base::in);
  std::string line;
  std::string detname;
  // Build a list of Rectangular/Grid Detectors (as component indices)
  std::vector<size_t> detList;
  for (size_t i = 0; i < componentInfo.size(); ++i) {
    if (componentInfo.isGridDetector(i)) {
      detList.emplace_back(i);
    }
  }
  std::unordered_set<int> uniqueBanks; // for CORELLI and WISH
  std::string bankPart = "bank";
  if (instname == "WISH")
    bankPart = "WISHpanel";
  if (detList.empty()) {
    // iterate over the top level components, which contain the banks
    size_t const rootIndex = componentInfo.root();
    auto const topChildren = componentInfo.children(rootIndex);
    for (size_t const i : topChildren) {
      int bank = 0;
      size_t bankParent = componentInfo.findBankParent(i, bankPart);
      auto const children = componentInfo.children(bankParent);
      for (size_t const child : children) {
        std::string bankName = componentInfo.name(child);
        boost::trim(bankName);
        boost::erase_all(bankName, bankPart);
        Strings::convert(bankName, bank);
        if (bank != 0) {
          uniqueBanks.insert(bank);
        }
      }
    }
  }
 
  std::vector<ComponentScaling> rectangularDetectorScalings;
 
  while (std::getline(input, line)) {
    if (line[0] == '7') {
      double mL1, mT0;
      std::stringstream(line) >> count >> mL1 >> mT0;
      setProperty("TimeOffset", mT0);
      // Convert from cm to m
      const std::string sourceName = instname == "WISH" ? "undulator" : "moderator";
      size_t sourceIndex;
      try {
        sourceIndex = componentInfo.indexOfAny(sourceName);
      } catch (const std::invalid_argument &) {
        throw std::runtime_error("Component with name " + sourceName + " was not found.");
      }
      center(0.0, 0.0, -mL1, sourceIndex, componentInfo);
      // mT0 and time of flight are both in microsec
      if (mT0 != 0.0) {
        if (inputW) {
          API::Run &run = inputW->mutableRun();
          // Check to see if LoadEventNexus had T0 from TOPAZ Parameter file
          auto alg1 = createChildAlgorithm("ChangeBinOffset");
          alg1->setProperty<MatrixWorkspace_sptr>("InputWorkspace", inputW);
          alg1->setProperty<MatrixWorkspace_sptr>("OutputWorkspace", inputW);
          if (run.hasProperty("T0")) {
            auto T0IDF = run.getPropertyValueAsType<double>("T0");
            alg1->setProperty("Offset", mT0 - T0IDF);
          } else {
            alg1->setProperty("Offset", mT0);
          }
          alg1->executeAsChildAlg();
          inputW = alg1->getProperty("OutputWorkspace");
          // set T0 in the run parameters
          run.addProperty<double>("T0", mT0, true);
        } else if (inputP) {
          // set T0 in the run parameters
          API::Run &run = inputP->mutableRun();
          run.addProperty<double>("T0", mT0, true);
        }
      }
    }
 
    if (line[0] != '5')
      continue;
 
    std::stringstream(line) >> count >> id >> nrows >> ncols >> width >> height >> depth >> detd >> x >> y >> z >>
        base_x >> base_y >> base_z >> up_x >> up_y >> up_z;
    if (id == 10 && filenames.size() == 2 && instname == "SNAP") {
      input.close();
      input.open(filenames[1].c_str());
      while (std::getline(input, line)) {
        if (line[0] != '5')
          continue;
 
        std::stringstream(line) >> count >> id >> nrows >> ncols >> width >> height >> depth >> detd >> x >> y >> z >>
            base_x >> base_y >> base_z >> up_x >> up_y >> up_z;
        if (id == 10)
          break;
      }
    }
    std::string bankName = getBankName(bankPart, id);
    auto matchingDetector = std::find_if(detList.begin(), detList.end(), [&bankName, &componentInfo](size_t index) {
      return componentInfo.name(index) == bankName;
    });
 
    V3D rX(base_x, base_y, base_z);
    V3D rY(up_x, up_y, up_z);
 
    if (matchingDetector != detList.end()) {
      const size_t bankIndex = *matchingDetector;
      detname = componentInfo.name(bankIndex);
      center(x, y, z, bankIndex, componentInfo);
 
      ComponentScaling detScaling;
      const auto grid = componentInfo.pixelGridComponent(bankIndex);
      detScaling.scaleX = CM_TO_M * width / (grid.nX * grid.xStep);
      detScaling.scaleY = CM_TO_M * height / (grid.nY * grid.yStep);
      detScaling.componentName = detname;
      // Scaling will need both scale factors if LoadIsawPeaks or LoadIsawDetCal
      // has already
      // applied a calibration
      if (inputW) {
        Geometry::ParameterMap const &pmap = inputW->instrumentParameters();
        auto oldscalex = pmap.getDouble(detname, std::string("scalex"));
        auto oldscaley = pmap.getDouble(detname, std::string("scaley"));
        if (!oldscalex.empty())
          detScaling.scaleX *= oldscalex[0];
        if (!oldscaley.empty())
          detScaling.scaleY *= oldscaley[0];
      }
      if (inputP) {
        Geometry::ParameterMap const &pmap = inputP->instrumentParameters();
        auto oldscalex = pmap.getDouble(detname, std::string("scalex"));
        auto oldscaley = pmap.getDouble(detname, std::string("scaley"));
        if (!oldscalex.empty())
          detScaling.scaleX *= oldscalex[0];
        if (!oldscaley.empty())
          detScaling.scaleY *= oldscaley[0];
      }
 
      rectangularDetectorScalings.emplace_back(detScaling);
 
      doRotation(rX, rY, componentInfo, bankIndex);
    }
    auto bank = uniqueBanks.find(id);
    if (bank == uniqueBanks.end())
      continue;
    int idnum = *bank;
 
    bankName = getBankName(bankPart, idnum);
    // Retrieve it
    size_t componentIndex;
    try {
      componentIndex = componentInfo.indexOfAny(bankName);
    } catch (const std::invalid_argument &) {
      continue;
    }
    // for Corelli with sixteenpack under bank
    if (instname == "CORELLI") {
      const auto children = componentInfo.children(componentIndex);
      if (!children.empty()) {
        componentIndex = children[0];
      }
    }
    // Omitted scaling tubes
    center(x, y, z, componentIndex, componentInfo);
 
    bool doWishCorrection = (instname == "WISH"); // TODO: find out why this is needed for WISH
    doRotation(rX, rY, componentInfo, componentIndex, doWishCorrection);
  }
 
  // Do this last, to avoid the issue of invalidating DetectorInfo
  applyScalings(ws, rectangularDetectorScalings);
 
  setProperty("InputWorkspace", ws);
}
 
void LoadIsawDetCal::center(const double x, const double y, const double z, const size_t componentIndex,
                            Geometry::ComponentInfo &componentInfo) {
  const V3D position(x * CM_TO_M, y * CM_TO_M, z * CM_TO_M);
  componentInfo.setPosition(componentIndex, position);
}
 
Instrument_sptr LoadIsawDetCal::getCheckInst(const API::Workspace_sptr &ws) {
  MatrixWorkspace_sptr inputW = std::dynamic_pointer_cast<MatrixWorkspace>(ws);
  PeaksWorkspace_sptr inputP = std::dynamic_pointer_cast<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");
  }
 
  return inst;
}
 
std::vector<std::string> LoadIsawDetCal::getFilenames() {
  std::vector<std::string> filenamesFromPropertyUnraveld;
  std::vector<std::vector<std::string>> filenamesFromProperty = this->getProperty("Filename");
  for (const auto &outer : filenamesFromProperty) {
    std::copy(outer.begin(), outer.end(), std::back_inserter(filenamesFromPropertyUnraveld));
  }
 
  // shouldn't be used except for legacy cases
  const std::string filename2 = this->getProperty("Filename2");
  if (!filename2.empty())
    filenamesFromPropertyUnraveld.emplace_back(filename2);
 
  return filenamesFromPropertyUnraveld;
}
 
void LoadIsawDetCal::doRotation(V3D rX, V3D rY, ComponentInfo &componentInfo, const size_t componentIndex,
                                bool doWishCorrection) {
  // These are the ISAW axes
  rX.normalize();
  rY.normalize();
 
  // These are the original axes
  constexpr V3D oX(1., 0., 0.);
  constexpr V3D oY(0., 1., 0.);
 
  // Axis that rotates X
  const V3D ax1 = oX.cross_prod(rX);
  Quat Q1;
  if (!ax1.nullVector(1e-12)) {
    // Rotation angle from oX to rX
    double angle1 = oX.angle(rX) * DegreesPerRadian;
    if (doWishCorrection)
      angle1 += 180.0;
    // Create the first quaternion
    Q1.setAngleAxis(angle1, ax1);
  }
 
  // Now we rotate the original Y using Q1
  V3D roY = oY;
  Q1.rotate(roY);
  // Find the axis that rotates oYr onto rY
  const V3D ax2 = roY.cross_prod(rY);
  Quat Q2;
  if (!ax2.nullVector(1e-12)) {
    const double angle2 = roY.angle(rY) * DegreesPerRadian;
    Q2.setAngleAxis(angle2, ax2);
  }
  // Final = those two rotations in succession; Q1 is done first.
  const Quat Rot = Q2 * Q1;
 
  componentInfo.setRotation(componentIndex, Rot);
}
 
void LoadIsawDetCal::applyScalings(Workspace_sptr &ws,
                                   const std::vector<ComponentScaling> &rectangularDetectorScalings) {
 
  for (const auto &scaling : rectangularDetectorScalings) {
    auto alg1 = createChildAlgorithm("ResizeRectangularDetector");
    alg1->setProperty<Workspace_sptr>("Workspace", ws);
    alg1->setProperty("ComponentName", scaling.componentName);
    alg1->setProperty("ScaleX", scaling.scaleX);
    alg1->setProperty("ScaleY", scaling.scaleY);
    alg1->executeAsChildAlg();
  }
}
 
} // namespace Mantid::DataHandling