ConvToMDSelector.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 "MantidMDAlgorithms/ConvToMDSelector.h"
 
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidMDAlgorithms/ConvToMDEventsWSIndexing.h"
#include "MantidMDAlgorithms/ConvToMDHistoWS.h"
 
namespace Mantid::MDAlgorithms {
// workspaces which currently can be converted to md workspaces:
enum wsType {
  Matrix2DWS, //< Workspace2D
  EventWS,    //< event workspace
  Undefined   //< unknown initial state
};
 
ConvToMDSelector::ConvToMDSelector(ConvToMDSelector::ConverterType tp) : converterType(tp) {}
 
std::shared_ptr<ConvToMDBase> ConvToMDSelector::convSelector(const API::MatrixWorkspace_sptr &inputWS,
                                                             std::shared_ptr<ConvToMDBase> &currentSolver) const {
  // identify what kind of workspace we expect to process
  wsType inputWSType = Undefined;
  if (std::dynamic_pointer_cast<DataObjects::EventWorkspace>(inputWS))
    inputWSType = EventWS;
  if (std::dynamic_pointer_cast<DataObjects::Workspace2D>(inputWS))
    inputWSType = Matrix2DWS;
 
  if (inputWSType == Undefined)
    throw(std::invalid_argument("ConvToDataObjectsSelector::got a workspace which "
                                "is neither matrix nor event workspace; Can "
                                "not deal with it"));
 
  // identify what converter (if any) is currently initialized;
  wsType existingWsConvType(Undefined);
  ConvToMDBase *pSolver = currentSolver.get();
  if (pSolver) {
    if (dynamic_cast<ConvToMDEventsWS *>(pSolver))
      existingWsConvType = EventWS;
    if (dynamic_cast<ConvToMDHistoWS *>(pSolver))
      existingWsConvType = Matrix2DWS;
  }
 
  std::shared_ptr<ConvToMDBase> res;
  // select a converter, which corresponds to the workspace type
  if ((existingWsConvType == Undefined) || (existingWsConvType != inputWSType)) {
    switch (inputWSType) {
    case (EventWS):
      // check if user set a property to use indexing
      if (converterType == ConvToMDSelector::DEFAULT)
        res = std::make_shared<ConvToMDEventsWS>();
      else
        res = std::make_shared<ConvToMDEventsWSIndexing>();
      break;
    case (Matrix2DWS):
      res = std::make_shared<ConvToMDHistoWS>();
      break;
    default:
      throw(std::logic_error("ConvToDataObjectsSelector: requested converter "
                             "for unknown ws type"));
    }
  } else {
    // existing converter is suitable for the workspace
    // in case of Event workspace check if user set a property to use indexing
    if (inputWSType == EventWS) {
      if (converterType == ConvToMDSelector::DEFAULT)
        res = std::make_shared<ConvToMDEventsWS>();
      else
        res = std::make_shared<ConvToMDEventsWSIndexing>();
    } else {
      res = std::make_shared<ConvToMDHistoWS>();
    }
  }
 
  return res;
}
} // namespace Mantid::MDAlgorithms