PeakStatisticsTools.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 "MantidCrystal/DllConfig.h"
#include "MantidDataObjects/Peak.h"
 
#include "MantidGeometry/Crystal/PointGroup.h"
#include "MantidGeometry/Crystal/ReflectionCondition.h"
#include "MantidGeometry/Crystal/UnitCell.h"
 
#include "MantidKernel/V3D.h"
 
namespace Mantid {
namespace Crystal {
namespace PeakStatisticsTools {
class MANTID_CRYSTAL_DLL UniqueReflection {
public:
  UniqueReflection(const Kernel::V3D &hkl) : m_hkl(hkl), m_peaks() {}
 
  const Kernel::V3D &getHKL() const { return m_hkl; }
 
  void addPeak(const DataObjects::Peak &peak) { m_peaks.emplace_back(peak); }
  const std::vector<DataObjects::Peak> &getPeaks() const { return m_peaks; }
  size_t count() const { return m_peaks.size(); }
 
  std::vector<double> getWavelengths() const;
  std::vector<double> getIntensities() const;
  std::vector<double> getSigmas() const;
 
  UniqueReflection removeOutliers(double sigmaCritical = 3.0, bool weightedZ = false) const;
  void setPeaksIntensityAndSigma(double intensity, double sigma);
 
private:
  Kernel::V3D m_hkl;
  std::vector<DataObjects::Peak> m_peaks;
};
 
class MANTID_CRYSTAL_DLL UniqueReflectionCollection {
public:
  UniqueReflectionCollection(const Geometry::UnitCell &cell, const std::pair<double, double> &dLimits,
                             Geometry::PointGroup_sptr pointGroup, const Geometry::ReflectionCondition_sptr &centering);
 
  ~UniqueReflectionCollection() = default;
 
  void addObservations(const std::vector<DataObjects::Peak> &peaks);
  UniqueReflection getReflection(const Kernel::V3D &hkl) const;
 
  size_t getUniqueReflectionCount() const;
  size_t getObservedUniqueReflectionCount(size_t moreThan = 0) const;
  std::vector<Kernel::V3D> getUnobservedUniqueReflections() const;
 
  size_t getObservedReflectionCount() const;
 
  const std::map<Kernel::V3D, UniqueReflection> &getReflections() const;
 
protected:
  UniqueReflectionCollection(const std::map<Kernel::V3D, UniqueReflection> &reflections,
                             const Geometry::PointGroup_sptr &pointGroup)
      : m_reflections(reflections), m_pointgroup(pointGroup) {}
 
private:
  std::map<Kernel::V3D, UniqueReflection> m_reflections;
  Geometry::PointGroup_sptr m_pointgroup;
};
 
class MANTID_CRYSTAL_DLL PeaksStatistics {
public:
  explicit PeaksStatistics(const UniqueReflectionCollection &reflections)
      : m_measuredReflections(0), m_uniqueReflections(0), m_completeness(0.0), m_redundancy(0.0), m_rMerge(0.0),
        m_rPim(0.0), m_meanIOverSigma(0.0), m_dspacingMin(0.0), m_dspacingMax(0.0), m_chiSquared(0.0), m_peaks() {
    m_peaks.reserve(reflections.getObservedReflectionCount());
    std::string equivalentIntensities = "Mean";
    double sigmaCritical = 3.0;
    bool weightedZ = false;
    calculatePeaksStatistics(reflections.getReflections(), equivalentIntensities, sigmaCritical, weightedZ);
  }
  explicit PeaksStatistics(const UniqueReflectionCollection &reflections, std::string &equivalentIntensities,
                           double &sigmaCritical, bool &weightedZ)
      : m_measuredReflections(0), m_uniqueReflections(0), m_completeness(0.0), m_redundancy(0.0), m_rMerge(0.0),
        m_rPim(0.0), m_meanIOverSigma(0.0), m_dspacingMin(0.0), m_dspacingMax(0.0), m_chiSquared(0.0), m_peaks() {
    m_peaks.reserve(reflections.getObservedReflectionCount());
    calculatePeaksStatistics(reflections.getReflections(), equivalentIntensities, sigmaCritical, weightedZ);
  }
 
  int m_measuredReflections;
 
  int m_uniqueReflections;
 
  double m_completeness;
 
  double m_redundancy;
 
  double m_rMerge;
 
  double m_rPim;
 
  double m_meanIOverSigma;
 
  double m_dspacingMin;
 
  double m_dspacingMax;
 
  double m_chiSquared;
  std::vector<DataObjects::Peak> m_peaks;
 
private:
  void calculatePeaksStatistics(const std::map<Kernel::V3D, UniqueReflection> &uniqueReflections,
                                std::string &equivalentIntensities, double &sigmaCritical, bool &weightedZ);
 
  double getIOverSigmaSum(const std::vector<double> &sigmas, const std::vector<double> &intensities) const;
  double getRMS(const std::vector<double> &data) const;
 
  std::pair<double, double> getDSpacingLimits(const std::vector<DataObjects::Peak> &peaks) const;
};
 
} // namespace PeakStatisticsTools
} // namespace Crystal
} // namespace Mantid