MDEventFactory.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 "MantidDataObjects/MDEventFactory.h"
#include "MantidAPI/IMDEventWorkspace.h"
#include "MantidDataObjects/MDEventWorkspace.h"
#include <memory>
 
#include "MantidDataObjects/MDBox.h"
#include "MantidDataObjects/MDBoxBase.h"
#include "MantidDataObjects/MDBoxIterator.h"
#include "MantidDataObjects/MDEvent.h"
#include "MantidDataObjects/MDEventWorkspace.h"
#include "MantidDataObjects/MDGridBox.h"
#include "MantidDataObjects/MDLeanEvent.h"
 
// We need to include the .cpp files so that the declarations are picked up
// correctly. Weird, I know.
// See http://www.parashift.com/c++-faq-lite/templates.html#faq-35.13
#include "MantidDataObjects/MDBox.hxx"
#include "MantidDataObjects/MDBoxBase.hxx"
#include "MantidDataObjects/MDBoxIterator.hxx"
#include "MantidDataObjects/MDEventWorkspace.hxx"
#include "MantidDataObjects/MDGridBox.hxx"
 
namespace Mantid::DataObjects {
// ### BEGIN AUTO-GENERATED CODE
/* Code below Auto-generated by 'generate_mdevent_declarations.py'
 *     on 2016-06-03 10:28:44.608989
 *
 * DO NOT EDIT!
 */
 
// Instantiations for MDLeanEvent
template class DLLExport MDLeanEvent<1>;
template class DLLExport MDLeanEvent<2>;
template class DLLExport MDLeanEvent<3>;
template class DLLExport MDLeanEvent<4>;
template class DLLExport MDLeanEvent<5>;
template class DLLExport MDLeanEvent<6>;
template class DLLExport MDLeanEvent<7>;
template class DLLExport MDLeanEvent<8>;
template class DLLExport MDLeanEvent<9>;
// Instantiations for MDEvent
template class DLLExport MDEvent<1>;
template class DLLExport MDEvent<2>;
template class DLLExport MDEvent<3>;
template class DLLExport MDEvent<4>;
template class DLLExport MDEvent<5>;
template class DLLExport MDEvent<6>;
template class DLLExport MDEvent<7>;
template class DLLExport MDEvent<8>;
template class DLLExport MDEvent<9>;
// Instantiations for MDBoxBase
template class DLLExport MDBoxBase<MDLeanEvent<1>, 1>;
template class DLLExport MDBoxBase<MDLeanEvent<2>, 2>;
template class DLLExport MDBoxBase<MDLeanEvent<3>, 3>;
template class DLLExport MDBoxBase<MDLeanEvent<4>, 4>;
template class DLLExport MDBoxBase<MDLeanEvent<5>, 5>;
template class DLLExport MDBoxBase<MDLeanEvent<6>, 6>;
template class DLLExport MDBoxBase<MDLeanEvent<7>, 7>;
template class DLLExport MDBoxBase<MDLeanEvent<8>, 8>;
template class DLLExport MDBoxBase<MDLeanEvent<9>, 9>;
template class DLLExport MDBoxBase<MDEvent<1>, 1>;
template class DLLExport MDBoxBase<MDEvent<2>, 2>;
template class DLLExport MDBoxBase<MDEvent<3>, 3>;
template class DLLExport MDBoxBase<MDEvent<4>, 4>;
template class DLLExport MDBoxBase<MDEvent<5>, 5>;
template class DLLExport MDBoxBase<MDEvent<6>, 6>;
template class DLLExport MDBoxBase<MDEvent<7>, 7>;
template class DLLExport MDBoxBase<MDEvent<8>, 8>;
template class DLLExport MDBoxBase<MDEvent<9>, 9>;
 
// Instantiations for MDBox
template class DLLExport MDBox<MDLeanEvent<1>, 1>;
template class DLLExport MDBox<MDLeanEvent<2>, 2>;
template class DLLExport MDBox<MDLeanEvent<3>, 3>;
template class DLLExport MDBox<MDLeanEvent<4>, 4>;
template class DLLExport MDBox<MDLeanEvent<5>, 5>;
template class DLLExport MDBox<MDLeanEvent<6>, 6>;
template class DLLExport MDBox<MDLeanEvent<7>, 7>;
template class DLLExport MDBox<MDLeanEvent<8>, 8>;
template class DLLExport MDBox<MDLeanEvent<9>, 9>;
template class DLLExport MDBox<MDEvent<1>, 1>;
template class DLLExport MDBox<MDEvent<2>, 2>;
template class DLLExport MDBox<MDEvent<3>, 3>;
template class DLLExport MDBox<MDEvent<4>, 4>;
template class DLLExport MDBox<MDEvent<5>, 5>;
template class DLLExport MDBox<MDEvent<6>, 6>;
template class DLLExport MDBox<MDEvent<7>, 7>;
template class DLLExport MDBox<MDEvent<8>, 8>;
template class DLLExport MDBox<MDEvent<9>, 9>;
 
// Instantiations for MDEventWorkspace
template class DLLExport MDEventWorkspace<MDLeanEvent<1>, 1>;
template class DLLExport MDEventWorkspace<MDLeanEvent<2>, 2>;
template class DLLExport MDEventWorkspace<MDLeanEvent<3>, 3>;
template class DLLExport MDEventWorkspace<MDLeanEvent<4>, 4>;
template class DLLExport MDEventWorkspace<MDLeanEvent<5>, 5>;
template class DLLExport MDEventWorkspace<MDLeanEvent<6>, 6>;
template class DLLExport MDEventWorkspace<MDLeanEvent<7>, 7>;
template class DLLExport MDEventWorkspace<MDLeanEvent<8>, 8>;
template class DLLExport MDEventWorkspace<MDLeanEvent<9>, 9>;
template class DLLExport MDEventWorkspace<MDEvent<1>, 1>;
template class DLLExport MDEventWorkspace<MDEvent<2>, 2>;
template class DLLExport MDEventWorkspace<MDEvent<3>, 3>;
template class DLLExport MDEventWorkspace<MDEvent<4>, 4>;
template class DLLExport MDEventWorkspace<MDEvent<5>, 5>;
template class DLLExport MDEventWorkspace<MDEvent<6>, 6>;
template class DLLExport MDEventWorkspace<MDEvent<7>, 7>;
template class DLLExport MDEventWorkspace<MDEvent<8>, 8>;
template class DLLExport MDEventWorkspace<MDEvent<9>, 9>;
 
// Instantiations for MDGridBox
template class DLLExport MDGridBox<MDLeanEvent<1>, 1>;
template class DLLExport MDGridBox<MDLeanEvent<2>, 2>;
template class DLLExport MDGridBox<MDLeanEvent<3>, 3>;
template class DLLExport MDGridBox<MDLeanEvent<4>, 4>;
template class DLLExport MDGridBox<MDLeanEvent<5>, 5>;
template class DLLExport MDGridBox<MDLeanEvent<6>, 6>;
template class DLLExport MDGridBox<MDLeanEvent<7>, 7>;
template class DLLExport MDGridBox<MDLeanEvent<8>, 8>;
template class DLLExport MDGridBox<MDLeanEvent<9>, 9>;
template class DLLExport MDGridBox<MDEvent<1>, 1>;
template class DLLExport MDGridBox<MDEvent<2>, 2>;
template class DLLExport MDGridBox<MDEvent<3>, 3>;
template class DLLExport MDGridBox<MDEvent<4>, 4>;
template class DLLExport MDGridBox<MDEvent<5>, 5>;
template class DLLExport MDGridBox<MDEvent<6>, 6>;
template class DLLExport MDGridBox<MDEvent<7>, 7>;
template class DLLExport MDGridBox<MDEvent<8>, 8>;
template class DLLExport MDGridBox<MDEvent<9>, 9>;
 
// Instantiations for MDBoxIterator
template class DLLExport MDBoxIterator<MDLeanEvent<1>, 1>;
template class DLLExport MDBoxIterator<MDLeanEvent<2>, 2>;
template class DLLExport MDBoxIterator<MDLeanEvent<3>, 3>;
template class DLLExport MDBoxIterator<MDLeanEvent<4>, 4>;
template class DLLExport MDBoxIterator<MDLeanEvent<5>, 5>;
template class DLLExport MDBoxIterator<MDLeanEvent<6>, 6>;
template class DLLExport MDBoxIterator<MDLeanEvent<7>, 7>;
template class DLLExport MDBoxIterator<MDLeanEvent<8>, 8>;
template class DLLExport MDBoxIterator<MDLeanEvent<9>, 9>;
template class DLLExport MDBoxIterator<MDEvent<1>, 1>;
template class DLLExport MDBoxIterator<MDEvent<2>, 2>;
template class DLLExport MDBoxIterator<MDEvent<3>, 3>;
template class DLLExport MDBoxIterator<MDEvent<4>, 4>;
template class DLLExport MDBoxIterator<MDEvent<5>, 5>;
template class DLLExport MDBoxIterator<MDEvent<6>, 6>;
template class DLLExport MDBoxIterator<MDEvent<7>, 7>;
template class DLLExport MDBoxIterator<MDEvent<8>, 8>;
template class DLLExport MDBoxIterator<MDEvent<9>, 9>;
 
/* CODE ABOVE WAS AUTO-GENERATED BY generate_mdevent_declarations.py - DO NOT
 * EDIT! */
 
// ### END AUTO-GENERATED CODE
// ##################################################################
 
//------------------------------- FACTORY METHODS
//------------------------------------------------------------------------------------------------------------------
 
API::IMDEventWorkspace_sptr
MDEventFactory::CreateMDWorkspace(size_t nd, const std::string &eventType,
                                  const Mantid::API::MDNormalization &preferredNormalization,
                                  const Mantid::API::MDNormalization &preferredNormalizationHisto) {
  if (nd > MAX_MD_DIMENSIONS_NUM)
    throw std::invalid_argument(" there are more dimensions requested then instantiated");
  API::IMDEventWorkspace *pWs = (*(wsCreatorFP[nd]))(eventType, preferredNormalization, preferredNormalizationHisto);
  return std::shared_ptr<API::IMDEventWorkspace>(pWs);
}
 
API::IMDNode *MDEventFactory::createBox(size_t nDimensions, MDEventFactory::BoxType Type,
                                        API::BoxController_sptr &splitter,
                                        const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector,
                                        const uint32_t depth, const size_t nBoxEvents, const size_t boxID) {
 
  if (nDimensions > MAX_MD_DIMENSIONS_NUM)
    throw std::invalid_argument(" there are more dimensions requested then instantiated");
 
  size_t id = nDimensions * MDEventFactory::NumBoxTypes + Type;
  if (extentsVector.size() != nDimensions) // set defaults
  {
    std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> defaultExtents(nDimensions);
    for (size_t i = 0; i < nDimensions; i++) {
      // set to smaller than float max, so the entire range fits in a float.
      defaultExtents[i].setExtents(-1e30f, 1e30f);
    }
    return (*(boxCreatorFP[id]))(splitter.get(), defaultExtents, depth, nBoxEvents, boxID);
  }
 
  return (*(boxCreatorFP[id]))(splitter.get(), extentsVector, depth, nBoxEvents, boxID);
}
 
//------------------------------- FACTORY METHODS END
//--------------------------------------------------------------------------------------------------------------
 
std::vector<MDEventFactory::fpCreateBox>
MDEventFactory::boxCreatorFP(MDEventFactory::NumBoxTypes *(MDEventFactory::MAX_MD_DIMENSIONS_NUM + 1), nullptr);
// static vector, conaining the pointers to the functions creating MD Workspaces
std::vector<MDEventFactory::fpCreateMDWS> MDEventFactory::wsCreatorFP(MDEventFactory::MAX_MD_DIMENSIONS_NUM + 1,
                                                                      nullptr);
 
// ########### Teplate methaprogrammed CODE SOURCE start:
//-------------------------------------
 
//-------------------------------------------------------------- MD Workspace
// constructor wrapper
template <size_t nd>
API::IMDEventWorkspace *
MDEventFactory::createMDWorkspaceND(const std::string &eventType,
                                    const Mantid::API::MDNormalization &preferredNormalization,
                                    const Mantid::API::MDNormalization &preferredNormalizationHisto) {
  if (eventType == "MDEvent")
    return new MDEventWorkspace<MDEvent<nd>, nd>(preferredNormalization, preferredNormalizationHisto);
  else if (eventType == "MDLeanEvent")
    return new MDEventWorkspace<MDLeanEvent<nd>, nd>(preferredNormalization, preferredNormalizationHisto);
  else
    throw std::invalid_argument("Unknown event type " + eventType + " passed to CreateMDWorkspace.");
}
template <>
API::IMDEventWorkspace *
MDEventFactory::createMDWorkspaceND<0>(const std::string &eventType,
                                       const Mantid::API::MDNormalization &preferredNormalization,
                                       const Mantid::API::MDNormalization &preferredNormalizationHisto) {
  UNUSED_ARG(eventType);
  UNUSED_ARG(preferredNormalization);
  UNUSED_ARG(preferredNormalizationHisto);
  throw std::invalid_argument("Workspace can not have 0 dimensions");
}
 
//-------------------------------------------------------------- MD BOX
// constructor wrapper
API::IMDNode *
MDEventFactory::createMDBoxWrong(API::BoxController * /*unused*/,
                                 const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> & /*unused*/,
                                 const uint32_t /*unused*/, const size_t /*unused*/, const size_t /*unused*/) {
  throw std::invalid_argument("MDBox/MDGridBox can not have 0 dimensions");
}
template <size_t nd>
API::IMDNode *
MDEventFactory::createMDBoxLean(API::BoxController *splitter,
                                const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector,
                                const uint32_t depth, const size_t nBoxEvents, const size_t boxID) {
  return new MDBox<MDLeanEvent<nd>, nd>(splitter, depth, extentsVector, nBoxEvents, boxID);
}
template <size_t nd>
API::IMDNode *
MDEventFactory::createMDBoxFat(API::BoxController *splitter,
                               const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector,
                               const uint32_t depth, const size_t nBoxEvents, const size_t boxID) {
  return new MDBox<MDEvent<nd>, nd>(splitter, depth, extentsVector, nBoxEvents, boxID);
}
template <size_t nd>
API::IMDNode *
MDEventFactory::createMDGridBoxLean(API::BoxController *splitter,
                                    const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector,
                                    const uint32_t depth, const size_t /*nBoxEvents*/, const size_t /*boxID*/) {
  return new MDGridBox<MDLeanEvent<nd>, nd>(splitter, depth, extentsVector);
}
template <size_t nd>
API::IMDNode *
MDEventFactory::createMDGridBoxFat(API::BoxController *splitter,
                                   const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector,
                                   const uint32_t depth, const size_t /*nBoxEvents*/, const size_t /*boxID*/) {
  return new MDGridBox<MDEvent<nd>, nd>(splitter, depth, extentsVector);
}
//-------------------------------------------------------------- MD BOX
// constructor wrapper -- END
 
// 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 nd> class LOOP {
public:
  LOOP() { EXEC(); }
  static inline void EXEC() {
    LOOP<nd - 1>::EXEC();
    MDEventFactory::wsCreatorFP[nd] = &MDEventFactory::createMDWorkspaceND<nd>;
 
    MDEventFactory::boxCreatorFP[MDEventFactory::NumBoxTypes * nd + MDEventFactory::MDBoxWithLean] =
        &MDEventFactory::createMDBoxLean<nd>;
    MDEventFactory::boxCreatorFP[MDEventFactory::NumBoxTypes * nd + MDEventFactory::MDBoxWithFat] =
        &MDEventFactory::createMDBoxFat<nd>;
    MDEventFactory::boxCreatorFP[MDEventFactory::NumBoxTypes * nd + MDEventFactory::MDGridBoxWithLean] =
        &MDEventFactory::createMDGridBoxLean<nd>;
    MDEventFactory::boxCreatorFP[MDEventFactory::NumBoxTypes * nd + MDEventFactory::MDGridBoxWithFat] =
        &MDEventFactory::createMDGridBoxFat<nd>;
  }
};
// the class terminates the compitlation-time metaloop and sets up functions
// which process 0-dimension workspace operations (throw invalid argument)
template <> class LOOP<0> {
public:
  static inline void EXEC() {
    MDEventFactory::wsCreatorFP[0] = &MDEventFactory::createMDWorkspaceND<0>;
 
    MDEventFactory::boxCreatorFP[MDEventFactory::MDBoxWithLean] = &MDEventFactory::createMDBoxWrong;
    MDEventFactory::boxCreatorFP[MDEventFactory::MDBoxWithFat] = &MDEventFactory::createMDBoxWrong;
    MDEventFactory::boxCreatorFP[MDEventFactory::MDGridBoxWithLean] = &MDEventFactory::createMDBoxWrong;
    MDEventFactory::boxCreatorFP[MDEventFactory::MDGridBoxWithFat] = &MDEventFactory::createMDBoxWrong;
  }
};
// ########### Teplate methaprogrammed CODE SOURCE END:
//-------------------------------------
//  statically instantiate the code, defined by the class above and assocoate it
//  with events factory
LOOP<MDEventFactory::MAX_MD_DIMENSIONS_NUM> MDEventFactory::CODE_GENERATOR;
 
} // namespace Mantid::DataObjects