SlicingAlgorithm.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2011 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 +
#pragma once
 
#include "MantidAPI/Algorithm.h"
#include "MantidAPI/CoordTransform.h"
#include "MantidAPI/IMDEventWorkspace_fwd.h"
#include "MantidAPI/IMDWorkspace.h"
#include "MantidDataObjects/CoordTransformAffine.h"
#include "MantidDataObjects/MDBox.h"
#include "MantidDataObjects/MDEventFactory.h"
#include "MantidDataObjects/MDEventWorkspace.h"
#include "MantidDataObjects/MDHistoWorkspace.h"
#include "MantidGeometry/MDGeometry/MDHistoDimension.h"
#include "MantidGeometry/MDGeometry/MDImplicitFunction.h"
#include "MantidKernel/VMD.h"
#include "MantidMDAlgorithms/DllConfig.h"
 
namespace Mantid {
namespace MDAlgorithms {
 
class MANTID_MDALGORITHMS_DLL SlicingAlgorithm : public API::Algorithm {
public:
  SlicingAlgorithm();
 
  static std::string getDimensionChars() { return "012345"; }
 
protected:
  ~SlicingAlgorithm() = default;
  void initSlicingProps();
 
  void createTransform();
 
  void createGeneralTransform();
  void processGeneralTransformProperties();
  void createAlignedTransform();
 
  void makeAlignedDimensionFromString(const std::string &str);
  void makeBasisVectorFromString(const std::string &str);
 
  std::unique_ptr<Mantid::Geometry::MDImplicitFunction> getImplicitFunctionForChunk(const size_t *const chunkMin,
                                                                                    const size_t *const chunkMax);
  std::unique_ptr<Mantid::Geometry::MDImplicitFunction> getGeneralImplicitFunction(const size_t *const chunkMin,
                                                                                   const size_t *const chunkMax);
 
  Mantid::API::IMDWorkspace_sptr m_inWS;
 
  Mantid::API::IMDWorkspace_sptr m_originalWS;
 
  std::vector<Mantid::Geometry::MDHistoDimension_sptr> m_binDimensions;
 
  std::vector<size_t> m_dimensionToBinFrom;
 
  std::unique_ptr<API::CoordTransform> m_transform;
 
  std::unique_ptr<API::CoordTransform> m_transformFromOriginal;
  std::unique_ptr<API::CoordTransform> m_transformToOriginal;
 
  Mantid::API::IMDWorkspace_sptr m_intermediateWS;
  std::unique_ptr<DataObjects::CoordTransformAffine> m_transformFromIntermediate;
  std::unique_ptr<DataObjects::CoordTransformAffine> m_transformToIntermediate;
 
  bool m_axisAligned;
 
  size_t m_outD;
 
  std::vector<Mantid::Kernel::VMD> m_bases;
 
  std::vector<double> m_binningScaling;
 
  std::vector<double> m_transformScaling;
 
  Mantid::Kernel::VMD m_translation;
 
  Mantid::Kernel::VMD m_inputMinPoint;
 
  std::vector<double> m_minExtents;
 
  std::vector<double> m_maxExtents;
 
  std::vector<int> m_numBins;
 
  bool m_NormalizeBasisVectors;
 
private:
  Mantid::Geometry::MDFrame_uptr createMDFrameForNonAxisAligned(const std::string &units,
                                                                const Mantid::Kernel::VMD &basisVector) const;
  std::vector<Mantid::Kernel::VMD> getOldBasis(size_t dimension) const;
  bool isProjectingOnFrame(const Mantid::Kernel::VMD &oldVector, const Mantid::Kernel::VMD &basisVector) const;
  std::vector<size_t> getIndicesWithProjection(const Mantid::Kernel::VMD &basisVector,
                                               const std::vector<Mantid::Kernel::VMD> &oldBasis) const;
  Mantid::Geometry::MDFrame_uptr extractMDFrameForNonAxisAligned(std::vector<size_t> indicesWithProjection,
                                                                 const std::string &units) const;
  void setTargetUnits(Mantid::Geometry::MDFrame_uptr &frame, const std::string &units) const;
};
 
} // namespace MDAlgorithms
} // namespace Mantid