MDNormBase.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2026 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/Run.h"
#include "MantidDataObjects/MDEventWorkspace.h"
#include "MantidDataObjects/MDHistoWorkspace.h"
#include "MantidGeometry/Crystal/SymmetryOperation.h"
#include "MantidGeometry/Instrument.h"
#include "MantidMDAlgorithms/DllConfig.h"
 
namespace Mantid::MDAlgorithms {
 
using Mantid::Kernel::DblMatrix;
 
template <typename PropertyType> auto getLogValues(const API::ExperimentInfo &exptInfo, const std::string &logName) {
  if (auto *prop = dynamic_cast<PropertyType *>(exptInfo.getLog(logName))) {
    return (*prop)();
  }
  throw std::runtime_error("Log property missing or wrong type: " + logName + ". Cannot continue.");
}
 
class MANTID_MDALGORITHMS_DLL MDNormBase : public API::Algorithm {
public:
  MDNormBase();
  // @return a string with the character that identifies each dimension in order (01234)
  static std::string getDimensionChars() { return "012345"; }
 
  // Parameters for continuous rotation processing when useLogTimes=True in ConvertToMD
  static constexpr double CHARGEBINSIZE = 1.0;    // Proton charge bin size in uA.hr for useLogTimes normalization
  static constexpr double GONIOBINSTEP = 0.25;    // Bin size in angle in degrees for useLogTimes normalization
  static constexpr double MINPROTONCHARGE = 0.1;  // Proton charge below which an angle will be ignored as no data
  static constexpr double STATIONARYANGLIM = 0.1; // Angle size (degrees) below which a gonio is considered stationary
 
protected:
  std::string inputEnergyMode() const;
  DataObjects::MDHistoWorkspace_sptr binInputWS();
  void createNormalizationWS(const DataObjects::MDHistoWorkspace &dataWS);
  std::vector<coord_t> getValuesFromOtherDimensions(bool &skipNormalization, uint16_t expInfoIndex = 0) const;
  void findIntegratedDimensions(const std::vector<coord_t> &otherDimValues, bool &skipNormalization);
  void cacheDimensionXValues();
  void calculateNormalization(const std::vector<coord_t> &otherValues, uint16_t expInfoIndex);
  void calculateNormalization(const std::vector<coord_t> &otherValues, const Geometry::SymmetryOperation &so,
                              uint16_t expInfoIndex);
  void calculateNormContinuous(const std::vector<coord_t> &otherValues, uint16_t expInfoIndex,
                               const Geometry::SymmetryOperation *so = nullptr);
  void calculateNormInner(const API::SpectrumInfo &spectrumInfo, const std::vector<coord_t> &otherValues,
                          const double protonCharge, const double protonChargeBkgd, const DblMatrix &Qtransform,
                          const std::vector<double> &lowValues = std::vector<double>(),
                          const std::vector<double> &highValues = std::vector<double>());
 
  void calcIntegralsForIntersections(const std::vector<double> &xValues, const API::MatrixWorkspace &integrFlux,
                                     size_t sp, std::vector<double> &yValues) const;
  void calculateIntersections(std::vector<std::array<double, 4>> &intersections, const double theta, const double phi,
                              const DblMatrix &transform, double lowvalue = std::nan(""), double highvalue = 0);
  Mantid::Kernel::DblMatrix calQTransform(const Kernel::DblMatrix &R, const Mantid::Geometry::SymmetryOperation &so,
                                          bool doInvert = true);
 
  API::IMDEventWorkspace_sptr m_inputWS;
  DataObjects::MDHistoWorkspace_sptr m_normWS;
  DataObjects::MDHistoWorkspace_sptr m_bkgdNormWS;
  API::IMDEventWorkspace_sptr m_backgroundWS;
  coord_t m_hmin, m_hmax, m_kmin, m_kmax, m_lmin, m_lmax, m_dEmin, m_dEmax;
  double m_Ei, m_ki, m_kfmin, m_kfmax;
  bool m_hIntegrated, m_kIntegrated, m_lIntegrated, m_dEIntegrated;
  Mantid::Kernel::DblMatrix m_UB;
  Mantid::Kernel::DblMatrix m_W;
  Mantid::Kernel::Matrix<coord_t> m_transformation;
  size_t m_hIdx, m_kIdx, m_lIdx, m_eIdx;
  std::vector<double> m_hX, m_kX, m_lX, m_eX;
  Kernel::V3D m_samplePos;
  Kernel::V3D m_beamDir;
  std::string m_convention;
  uint16_t m_numExptInfos;
  bool m_diffraction;
  bool m_accumulate;
  std::unique_ptr<API::Progress> m_progress;
  std::vector<std::atomic<signal_t>> m_signalArray;
  std::vector<std::atomic<signal_t>> m_bkgdSignalArray;
};
 
} // namespace Mantid::MDAlgorithms