MDEventWSWrapper.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 "MantidGeometry/MDGeometry/MDTypes.h"
#include "MantidMDAlgorithms/MDEventWSWrapper.h"
 
namespace Mantid::MDAlgorithms {
 
template <size_t nd> void MDEventWSWrapper::createEmptyEventWS(const MDWSDescription &description) {
 
  std::shared_ptr<DataObjects::MDEventWorkspace<DataObjects::MDEvent<nd>, nd>> ws =
      std::shared_ptr<DataObjects::MDEventWorkspace<DataObjects::MDEvent<nd>, nd>>(
          new DataObjects::MDEventWorkspace<DataObjects::MDEvent<nd>, nd>());
 
  auto numBins = description.getNBins();
  size_t nBins(10); // HACK. this means we have 10 bins artificially. This can't
                    // be right.
  // Give all the dimensions
  for (size_t d = 0; d < nd; d++) {
    if (!numBins.empty())
      nBins = numBins[d];
 
    Geometry::MDHistoDimension *dim = nullptr;
    if (d < 3 && description.isQ3DMode()) {
      // We should have frame and scale information that we can use correctly
      // for our Q dimensions.
      auto mdFrame = description.getFrame(d);
 
      dim = new Geometry::MDHistoDimension(description.getDimNames()[d], description.getDimIDs()[d], *mdFrame,
                                           Mantid::coord_t(description.getDimMin()[d]),
                                           Mantid::coord_t(description.getDimMax()[d]), nBins);
 
    } else {
      Mantid::Geometry::GeneralFrame frame(description.getDimNames()[d], description.getDimUnits()[d]);
      dim = new Geometry::MDHistoDimension(description.getDimNames()[d], description.getDimIDs()[d], frame,
                                           Mantid::coord_t(description.getDimMin()[d]),
                                           Mantid::coord_t(description.getDimMax()[d]), nBins);
    }
 
    ws->addDimension(Geometry::MDHistoDimension_sptr(dim));
  }
  ws->initialize();
 
  m_Workspace = ws;
}
template <> void MDEventWSWrapper::createEmptyEventWS<0>(const MDWSDescription & /*unused*/) {
  throw(std::invalid_argument("MDEventWSWrapper:createEmptyEventWS can not be "
                              "initiated with 0 dimensions"));
}
 
template <size_t nd>
void MDEventWSWrapper::addMDDataND(const float *sigErr, const uint16_t *expInfoIndex, const uint16_t *goniometerIndex,
                                   const uint32_t *detId, const coord_t *Coord, size_t dataSize) const {
 
  auto *const pWs = dynamic_cast<DataObjects::MDEventWorkspace<DataObjects::MDEvent<nd>, nd> *>(m_Workspace.get());
  if (pWs) {
    for (size_t i = 0; i < dataSize; i++) {
      pWs->addEvent(DataObjects::MDEvent<nd>(*(sigErr + 2 * i), *(sigErr + 2 * i + 1), *(expInfoIndex + i),
                                             *(goniometerIndex + i), *(detId + i), (Coord + i * nd)));
    }
  } else {
    auto *const pLWs =
        dynamic_cast<DataObjects::MDEventWorkspace<DataObjects::MDLeanEvent<nd>, nd> *>(m_Workspace.get());
 
    if (!pLWs)
      throw std::runtime_error("Bad Cast: Target MD workspace to add events "
                               "does not correspond to type of events you try "
                               "to add to it");
 
    for (size_t i = 0; i < dataSize; i++) {
      pLWs->addEvent(DataObjects::MDLeanEvent<nd>(*(sigErr + 2 * i), *(sigErr + 2 * i + 1), (Coord + i * nd)));
    }
  }
}
 
template <>
void MDEventWSWrapper::addMDDataND<0>(const float * /*unused*/, const uint16_t * /*unused*/,
                                      const uint16_t * /*unused*/, const uint32_t * /*unused*/,
                                      const coord_t * /*unused*/, size_t /*unused*/) const {
  throw(std::invalid_argument(" class has not been initiated, can not add data "
                              "to 0-dimensional workspace"));
}
 
template <size_t nd> void MDEventWSWrapper::splitBoxList() {
  auto *const pWs = dynamic_cast<DataObjects::MDEventWorkspace<DataObjects::MDEvent<nd>, nd> *>(m_Workspace.get());
  if (!pWs)
    throw(std::bad_cast());
 
  m_needSplitting = false;
}
 
template <> void MDEventWSWrapper::splitBoxList<0>() {
  throw(std::invalid_argument(" class has not been initiated, can not split "
                              "0-dimensional workspace boxes"));
}
 
template <size_t nd> void MDEventWSWrapper::calcCentroidND() {
 
  auto *const pWs =
      dynamic_cast<DataObjects::MDEventWorkspace<DataObjects::MDEvent<nd>, nd> *>(this->m_Workspace.get());
  if (!pWs)
    throw(std::bad_cast());
 
  // pWs->getBox()->refreshCentroid(NULL);
}
template <> void MDEventWSWrapper::calcCentroidND<0>() {
  throw(std::invalid_argument(" class has not been initiated"));
}
 
size_t MDEventWSWrapper::nDimensions() const {
  if (m_NDimensions == 0)
    throw(std::invalid_argument("The workspace has not been initiated yet"));
  return size_t(m_NDimensions);
}
 
API::IMDEventWorkspace_sptr MDEventWSWrapper::createEmptyMDWS(const MDWSDescription &WSD) {
 
  if (WSD.nDimensions() < 1 || WSD.nDimensions() > MAX_N_DIM) {
    std::string ERR = " Number of requested MD dimensions: " + std::to_string(WSD.nDimensions()) +
                      " exceeds maximal number of MD dimensions: " + std::to_string(static_cast<int>(MAX_N_DIM)) +
                      " instantiated during compilation\n";
    throw(std::invalid_argument(ERR));
  }
 
  m_NDimensions = static_cast<int>(WSD.nDimensions());
  // call the particular function, which creates the workspace with n_dimensions
  (this->*(wsCreator[m_NDimensions]))(WSD);
 
  // set up the matrix, which convert momentums from Q in orthogonal crystal
  // coordinate system and units of Angstrom^-1 to hkl or orthogonal hkl or
  // whatever
  m_Workspace->setWTransf(WSD.m_Wtransf);
  return m_Workspace;
}
 
void MDEventWSWrapper::setMDWS(API::IMDEventWorkspace_sptr spWS) {
  m_Workspace = std::move(spWS);
  m_NDimensions = m_Workspace->getNumDims();
}
 
void MDEventWSWrapper::addMDData(std::vector<float> &sigErr, std::vector<uint16_t> &expInfoIndex,
                                 std::vector<uint16_t> &goniometerIndex, std::vector<uint32_t> &detId,
                                 std::vector<coord_t> &Coord, size_t dataSize) const {
 
  if (dataSize == 0)
    return;
  // perform the actual dimension-dependent addition
  (this->*(mdEvAddAndForget[m_NDimensions]))(&sigErr[0], &expInfoIndex[0], &goniometerIndex[0], &detId[0], &Coord[0],
                                             dataSize);
}
 
void MDEventWSWrapper::releaseWorkspace() {
  // decrease the sp count by one
  m_Workspace.reset();
  // mark the number of dimensions invalid;
  m_NDimensions = 0;
}
 
// the class instantiated by compiler at compilation time and generates the map,
// between the number of dimensions and the function, which process this number
// of dimensions
template <size_t i> class LOOP {
public:
  static inline void EXEC(MDEventWSWrapper *pH) {
    LOOP<i - 1>::EXEC(pH);
    pH->wsCreator[i] = &MDEventWSWrapper::createEmptyEventWS<i>;
    pH->mdEvAddAndForget[i] = &MDEventWSWrapper::addMDDataND<i>;
    pH->mdCalCentroid[i] = &MDEventWSWrapper::calcCentroidND<i>;
    pH->mdBoxListSplitter[i] = &MDEventWSWrapper::splitBoxList<i>;
  }
};
// the class terminates the compitlation-time metaloop and sets up functions
// which process 0-dimension workspace operations
template <> class LOOP<0> {
public:
  static inline void EXEC(MDEventWSWrapper *pH) {
    pH->wsCreator[0] = &MDEventWSWrapper::createEmptyEventWS<0>;
    pH->mdEvAddAndForget[0] = &MDEventWSWrapper::addMDDataND<0>;
    pH->mdCalCentroid[0] = &MDEventWSWrapper::calcCentroidND<0>;
    pH->mdBoxListSplitter[0] = &MDEventWSWrapper::splitBoxList<0>;
  }
};
 
MDEventWSWrapper::MDEventWSWrapper() : m_NDimensions(0), m_needSplitting(false) {
  wsCreator.resize(MAX_N_DIM + 1);
  mdEvAddAndForget.resize(MAX_N_DIM + 1);
  mdCalCentroid.resize(MAX_N_DIM + 1);
  mdBoxListSplitter.resize(MAX_N_DIM + 1);
  LOOP<MAX_N_DIM>::EXEC(this);
}
 
} // namespace Mantid::MDAlgorithms