ConvToMDBase.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 <utility>
 
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/Run.h"
#include "MantidKernel/Logger.h"
#include "MantidMDAlgorithms/ConvToMDBase.h"
 
namespace Mantid::MDAlgorithms {
 
// logger for conversion
Kernel::Logger ConvToMDBase::g_Log("MD-Algorithms");
 
size_t ConvToMDBase::initialize(const MDAlgorithms::MDWSDescription &WSD,
                                std::shared_ptr<MDAlgorithms::MDEventWSWrapper> inWSWrapper, bool ignoreZeros,
                                bool useLogTimes) {
  m_ignoreZeros = ignoreZeros;
  m_useLogTimes = useLogTimes;
  m_InWS2D = WSD.getInWS();
  // preprocessed detectors information:
  // check if detector information has been precalculated:
  if (!WSD.m_PreprDetTable)
    throw(std::runtime_error("Detector information has to be precalculated "
                             "before ConvToMDBase::initialize is deployed"));
 
  // number of valid spectra is equal to actual number of valid detectors in
  // spectra-det map
  m_NSpectra = WSD.m_PreprDetTable->getLogs()->getPropertyValueAsType<uint32_t>("ActualDetectorsNum");
  m_detIDMap = WSD.m_PreprDetTable->getColVector<size_t>("detIDMap");
  m_detID = WSD.m_PreprDetTable->getColVector<int>("DetectorID");
 
  // set up output MD workspace wrapper
  m_OutWSWrapper = std::move(inWSWrapper);
  // get the index which identify the run the source workspace came from.
  // This index will mark the workspace' events for diffetent worksapces to
  // combine
  m_ExpInfoIndex = WSD.getPropertyValueAsType<uint16_t>("EXP_INFO_INDEX");
 
  m_NDims = m_OutWSWrapper->nDimensions();
  // allocate space for single MDEvent coordinates
  m_Coord.resize(m_NDims);
 
  // retrieve the class which does the conversion of workspace data into MD WS
  // coordinates;
  m_QConverter = MDTransfFactory::Instance().create(WSD.AlgID);
 
  // initialize the MD coordinates conversion class
  m_QConverter->initialize(WSD);
  // initialize units conversion which can/or can not be necessary depending on
  // input ws/converter requested units;
  Kernel::DeltaEMode::Type emode = WSD.getEMode();
  m_UnitConversion.initialize(WSD, m_QConverter->inputUnitID(emode, m_InWS2D));
 
  size_t n_spectra = m_InWS2D->getNumberHistograms();
 
  // get property which controls multithreaded run. If present, this property
  // describes number of threads (or one) deployed to run conversion
  // (this can be for debugging or other tricky reasons)
  m_NumThreads = -1;
  try {
    Kernel::Property *pProperty = m_InWS2D->run().getProperty("NUM_THREADS");
    auto *thrProperty = dynamic_cast<Kernel::PropertyWithValue<double> *>(pProperty);
    if (thrProperty) {
      auto nDThrheads = double(*(thrProperty));
      try {
        m_NumThreads = boost::lexical_cast<int>(nDThrheads);
        g_Log.information() << "***--> NUM_THREADS property set to: " << m_NumThreads << '\n';
        if (m_NumThreads < 0)
          g_Log.information() << "***--> This resets number of threads to the "
                                 "number of physical cores\n ";
        else if (m_NumThreads == 0)
          g_Log.information() << "***--> This disables multithreading\n ";
        else if (m_NumThreads > 0)
          g_Log.information() << "***--> Multithreading processing will launch " << m_NumThreads << " Threads\n";
      } catch (...) {
      };
    }
  } catch (Kernel::Exception::NotFoundError &) {
  }
 
  // Record any special coordinate system known to the description.
  m_coordinateSystem = WSD.getCoordinateSystem();
 
  return n_spectra;
}
 
ConvToMDBase::ConvToMDBase()
    : m_NDims(0),           // wrong non-initialized
      m_ExpInfoIndex(0),    // defauld associated experiment-info index is 0
      m_NSpectra(0),        // no valid spectra by default.
      m_NumThreads(-1),     // run with all cores availible
      m_ignoreZeros(false), // 0-s added to workspace
      m_coordinateSystem(Mantid::Kernel::None), m_useLogTimes(false) {}
 
void ConvToMDBase::setDisplayNormalization(Mantid::API::IMDEventWorkspace_sptr mdWorkspace,
                                           const Mantid::API::MatrixWorkspace_sptr &underlyingWorkspace) {
  if (m_QConverter) {
    m_QConverter->setDisplayNormalization(mdWorkspace, underlyingWorkspace);
  }
}
 
} // namespace Mantid::MDAlgorithms