MDNorm.h

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 +
#pragma once
 
#include "MantidAPI/Algorithm.h"
#include "MantidAPI/ExperimentInfo.h"
#include "MantidGeometry/Crystal/SymmetryOperationFactory.h"
#include "MantidMDAlgorithms/DllConfig.h"
#include "MantidMDAlgorithms/SlicingAlgorithm.h"
 
namespace Mantid {
namespace MDAlgorithms {
 
class MANTID_MDALGORITHMS_DLL MDNorm final : public API::Algorithm {
public:
  MDNorm();
  const std::string name() const override;
  int version() const override;
  const std::string category() const override;
  const std::string summary() const override;
  const std::vector<std::string> seeAlso() const override {
    return {"CropWorkspaceForMDNorm", "MDNormSCD", "MDNormDirectSC", "RecalculateTrajectoriesExtents"};
  }
 
private:
  void init() override;
  void exec() override;
  void validateBinningForTemporaryDataWorkspace(const std::map<std::string, std::string> &,
                                                const Mantid::API::IMDHistoWorkspace_sptr &);
  std::map<std::string, std::string> validateInputs() override final;
  std::string QDimensionName(std::vector<double> projection);
  std::string QDimensionNameQSample(int i);
  std::map<std::string, std::string> getBinParameters();
  void createNormalizationWS(const DataObjects::MDHistoWorkspace &dataWS);
  void createBackgroundNormalizationWS(const DataObjects::MDHistoWorkspace &dataWS);
 
  DataObjects::MDHistoWorkspace_sptr binInputWS(const std::vector<Geometry::SymmetryOperation> &symmetryOps);
 
  DataObjects::MDHistoWorkspace_sptr binBackgroundWS(const std::vector<Geometry::SymmetryOperation> &symmetryOps);
 
  Mantid::Kernel::DblMatrix buildSymmetryMatrix(const Geometry::SymmetryOperation &so);
  void determineBasisVector(const size_t &qindex, const std::string &value, const Kernel::DblMatrix &Qtransform,
                            std::vector<double> &projection, std::stringstream &basisVector,
                            std::vector<size_t> &qDimensionIndices);
  inline void setQUnit(const std::vector<size_t> &qDimensionIndices,
                       const Mantid::DataObjects::MDHistoWorkspace_sptr &outputMDHWS);
 
  std::vector<coord_t> getValuesFromOtherDimensions(bool &skipNormalization, uint16_t expInfoIndex = 0) const;
 
  void cacheDimensionXValues();
  void calculateNormalization(const std::vector<coord_t> &otherValues, const Geometry::SymmetryOperation &so,
                              uint16_t expInfoIndex, size_t soIndex);
 
  void calculateIntersections(std::vector<std::array<double, 4>> &intersections, const double theta, const double phi,
                              const Kernel::DblMatrix &transform, double lowvalue, double highvalue);
 
  void calcIntegralsForIntersections(const std::vector<double> &xValues, const API::MatrixWorkspace &integrFlux,
 
                                     size_t sp, std::vector<double> &yValues);
 
  void calcDiffractionIntersectionIntegral(std::vector<std::array<double, 4>> &intersections,
                                           std::vector<double> &xValues, std::vector<double> &yValues,
                                           const API::MatrixWorkspace &integrFlux, const size_t &wsIdx);
 
  Mantid::Kernel::DblMatrix calQTransform(const Mantid::API::ExperimentInfo &currentExpInfo,
                                          const Geometry::SymmetryOperation &so);
 
  void calcSingleDetectorNorm(const std::vector<std::array<double, 4>> &intersections, const double &solid,
                              std::vector<double> &yValues, const size_t &vmdDims, std::vector<coord_t> &pos,
                              std::vector<coord_t> &posNew, std::vector<std::atomic<signal_t>> &signalArray,
                              const double &solidBkgd, std::vector<std::atomic<signal_t>> &bkgdSignalArray);
 
  API::IMDWorkspace_sptr divideMD(const API::IMDHistoWorkspace_sptr &lhs, const API::IMDHistoWorkspace_sptr &rhs,
                                  const std::string &outputwsname, const double &startProgress,
                                  const double &endProgress);
 
  DataObjects::MDHistoWorkspace_sptr m_normWS;
  DataObjects::MDHistoWorkspace_sptr m_bkgdNormWS;
  API::IMDEventWorkspace_sptr m_inputWS;
  API::IMDEventWorkspace_sptr m_backgroundWS;
 
  bool m_isRLU;
  std::vector<double> m_Q0Basis{1., 0., 0.}, m_Q1Basis{0., 1., 0.}, m_Q2Basis{0., 0., 1.};
  Mantid::Kernel::DblMatrix m_UB;
  Mantid::Kernel::DblMatrix m_W;
  Mantid::Kernel::Matrix<coord_t> m_transformation;
  std::vector<double> m_hX, m_kX, m_lX, m_eX;
  size_t m_hIdx, m_kIdx, m_lIdx, m_eIdx;
  size_t m_numExptInfos;
  size_t m_numSymmOps;
  double m_Ei;
  bool m_diffraction;
  bool m_accumulate;
  bool m_dEIntegrated;
  Kernel::V3D m_samplePos;
  Kernel::V3D m_beamDir;
  std::string convention;
};
 
} // namespace MDAlgorithms
} // namespace Mantid