Integrate3DEvents.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2012 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 "MantidDataObjects/Peak.h"
#include "MantidDataObjects/PeakShapeEllipsoid.h"
#include "MantidKernel/Matrix.h"
#include "MantidKernel/V3D.h"
#include "MantidMDAlgorithms/DllConfig.h"
 
#include <memory>
 
#include <tuple>
#include <unordered_map>
#include <vector>
 
namespace Mantid {
namespace Geometry {
class PeakShape;
}
namespace DataObjects {
class PeakShapeEllipsoid;
}
namespace MDAlgorithms {
 
struct IntegrationParameters {
  std::vector<Kernel::V3D> E1Vectors;
  double backgroundInnerRadius;
  double backgroundOuterRadius;
  double regionRadius;
  double peakRadius;
  bool specifySize;
};
 
using EventListMap =
    std::unordered_map<int64_t, std::vector<std::pair<std::pair<double, double>, Mantid::Kernel::V3D>>>;
using PeakQMap = std::unordered_map<int64_t, Mantid::Kernel::V3D>;
 
class MANTID_MDALGORITHMS_DLL Integrate3DEvents {
public:
  Integrate3DEvents(const std::vector<std::pair<std::pair<double, double>, Mantid::Kernel::V3D>> &peak_q_list,
                    Kernel::DblMatrix UBinv, double radius, const bool useOnePercentBackgroundCorrection = true);
 
  Integrate3DEvents(const std::vector<std::pair<std::pair<double, double>, Mantid::Kernel::V3D>> &peak_q_list,
                    std::vector<Mantid::Kernel::V3D> const &hkl_list, std::vector<Mantid::Kernel::V3D> const &mnp_list,
                    Kernel::DblMatrix UBinv, Kernel::DblMatrix ModHKL, double radius_m, double radius_s, int MaxO,
                    const bool CrossT, const bool useOnePercentBackgroundCorrection = true);
 
  void addEvents(std::vector<std::pair<std::pair<double, double>, Mantid::Kernel::V3D>> const &event_qs,
                 bool hkl_integ);
 
  std::shared_ptr<const Mantid::Geometry::PeakShape>
  ellipseIntegrateEvents(const std::vector<Kernel::V3D> &E1Vec, Mantid::Kernel::V3D const &peak_q, bool specify_size,
                         double peak_radius, double back_inner_radius, double back_outer_radius,
                         std::vector<double> &axes_radii, double &inti, double &sigi);
 
  std::shared_ptr<const Mantid::Geometry::PeakShape>
  ellipseIntegrateModEvents(const std::vector<Kernel::V3D> &E1Vec, Mantid::Kernel::V3D const &peak_q,
                            Mantid::Kernel::V3D const &hkl, Mantid::Kernel::V3D const &mnp, bool specify_size,
                            double peak_radius, double back_inner_radius, double back_outer_radius,
                            std::vector<double> &axes_radii, double &inti, double &sigi);
 
  std::pair<std::shared_ptr<const Mantid::Geometry::PeakShape>, std::tuple<double, double, double>>
  integrateStrongPeak(const IntegrationParameters &params, const Kernel::V3D &peak_q, double &inti, double &sigi);
 
  std::shared_ptr<const Geometry::PeakShape> integrateWeakPeak(const IntegrationParameters &params,
                                                               Mantid::DataObjects::PeakShapeEllipsoid_const_sptr shape,
                                                               const std::tuple<double, double, double> &libPeak,
                                                               const Mantid::Kernel::V3D &peak_q, double &inti,
                                                               double &sigi);
 
  double estimateSignalToNoiseRatio(const IntegrationParameters &params, const Mantid::Kernel::V3D &center,
                                    bool forceSpherical = false, double sphericityTol = 0.02);
 
private:
  const std::vector<std::pair<std::pair<double, double>, Mantid::Kernel::V3D>> *
  getEvents(const Mantid::Kernel::V3D &peak_q);
 
  bool correctForDetectorEdges(std::tuple<double, double, double> &radii,
                               const std::vector<Mantid::Kernel::V3D> &E1Vecs, const Mantid::Kernel::V3D &peak_q,
                               const std::vector<double> &axesRadii, const std::vector<double> &bkgInnerRadii,
                               const std::vector<double> &bkgOuterRadii);
 
  static std::pair<double, double>
  numInEllipsoid(std::vector<std::pair<std::pair<double, double>, Mantid::Kernel::V3D>> const &events,
                 std::vector<Mantid::Kernel::V3D> const &directions, std::vector<double> const &sizes);
 
  static std::pair<double, double>
  numInEllipsoidBkg(std::vector<std::pair<std::pair<double, double>, Mantid::Kernel::V3D>> const &events,
                    std::vector<Mantid::Kernel::V3D> const &directions, std::vector<double> const &sizes,
                    std::vector<double> const &sizesIn, const bool useOnePercentBackgroundCorrection);
 
  static void makeCovarianceMatrix(std::vector<std::pair<std::pair<double, double>, Mantid::Kernel::V3D>> const &events,
                                   Kernel::DblMatrix &matrix, double radius);
 
  static void getEigenVectors(Kernel::DblMatrix const &cov_matrix, std::vector<Mantid::Kernel::V3D> &eigen_vectors,
                              std::vector<double> &eigen_values);
 
  static int64_t getHklKey(int h, int k, int l);
 
  static int64_t getHklMnpKey(int h, int k, int l, int m, int n, int p);
 
  int64_t getHklKey(Mantid::Kernel::V3D const &q_vector);
  int64_t getHklMnpKey(Mantid::Kernel::V3D const &q_vector);
  int64_t getHklKey2(Mantid::Kernel::V3D const &hkl);
  int64_t getHklMnpKey2(Mantid::Kernel::V3D const &hkl);
 
  void addEvent(std::pair<std::pair<double, double>, Mantid::Kernel::V3D> event_Q, bool hkl_integ);
  void addModEvent(std::pair<std::pair<double, double>, Mantid::Kernel::V3D> event_Q, bool hkl_integ);
 
  std::shared_ptr<const Mantid::DataObjects::PeakShapeEllipsoid>
  ellipseIntegrateEvents(const std::vector<Kernel::V3D> &E1Vec, Kernel::V3D const &peak_q,
                         std::vector<std::pair<std::pair<double, double>, Mantid::Kernel::V3D>> const &ev_list,
                         std::vector<Mantid::Kernel::V3D> const &directions, std::vector<double> const &sigmas,
                         bool specify_size, double peak_radius, double back_inner_radius, double back_outer_radius,
                         std::vector<double> &axes_radii, double &inti, double &sigi);
 
  double detectorQ(const std::vector<Kernel::V3D> &E1Vec, const Mantid::Kernel::V3D &QLabFrame,
                   const std::vector<double> &r);
 
  std::tuple<double, double, double> calculateRadiusFactors(const IntegrationParameters &params,
                                                            double max_sigma) const;
 
  // Private data members
 
  PeakQMap m_peak_qs;         // hashtable with peak Q-vectors
  EventListMap m_event_lists; // hashtable with lists of events for each peak
  Kernel::DblMatrix m_UBinv;  // matrix mapping from Q to h,k,l
  Kernel::DblMatrix m_ModHKL; // matrix mapping from Q to m,n,p
  double m_radius;            // size of sphere to use for events around a peak
  double s_radius;            // size of sphere to use for events around a peak
  int maxOrder;
  const bool crossterm;
  const bool m_useOnePercentBackgroundCorrection =
      true; // if one perecent culling of the background should be performed.
};
 
} // namespace MDAlgorithms
 
} // namespace Mantid