WeightingStrategy.cpp

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 +
#include "MantidAlgorithms/WeightingStrategy.h"
#include "MantidKernel/System.h"
 
#include <cmath>
#include <stdexcept>
 
namespace Mantid::Algorithms {
 
//----------------------------------------------------------------------------
// Weighting Implementations
//----------------------------------------------------------------------------
 
WeightingStrategy::WeightingStrategy(const double cutOff) : m_cutOff(cutOff) {}
 
WeightingStrategy::WeightingStrategy() : m_cutOff(0) {}
 
//----------------------------------------------------------------------------
// Flat Weighting Implementations
//----------------------------------------------------------------------------
 
double FlatWeighting::weightAt(const double & /*adjX*/, const double & /*ix*/, const double & /*adjY*/,
                               const double & /*iy*/) {
  return 1;
}
 
double FlatWeighting::weightAt(const Mantid::Kernel::V3D & /*distance*/) { return 1; }
 
//----------------------------------------------------------------------------
// Linear Weighting Implementations
//----------------------------------------------------------------------------
 
LinearWeighting::LinearWeighting(const double cutOff) : WeightingStrategy(cutOff) {}
 
double LinearWeighting::weightAt(const Mantid::Kernel::V3D &distance) { return 1 - (distance.norm() / m_cutOff); }
 
double LinearWeighting::weightAt(const double &adjX, const double &ix, const double &adjY, const double &iy) {
  return 1 - (std::sqrt(ix * ix + iy * iy) / std::sqrt(adjX * adjX + adjY * adjY));
}
 
//----------------------------------------------------------------------------
// Parabolic Weighting Implementations
//----------------------------------------------------------------------------
 
ParabolicWeighting::ParabolicWeighting(const double cutOff) : WeightingStrategy(cutOff) {}
 
double ParabolicWeighting::weightAt(const Mantid::Kernel::V3D &distance) {
  return static_cast<double>(m_cutOff - std::abs(distance.X()) + m_cutOff - std::abs(distance.Y()) + 1);
}
 
double ParabolicWeighting::weightAt(const double &adjX, const double &ix, const double &adjY, const double &iy) {
  return static_cast<double>(adjX - std::abs(ix) + adjY - std::abs(iy) + 1);
}
 
//----------------------------------------------------------------------------
// Null Weighting Implementations
//----------------------------------------------------------------------------
 
double NullWeighting::weightAt(const Mantid::Kernel::V3D & /*distance*/) {
  throw std::runtime_error("NullWeighting strategy cannot be used to evaluate weights.");
}
 
double NullWeighting::weightAt(const double & /*adjX*/, const double & /*ix*/, const double & /*adjY*/,
                               const double & /*iy*/) {
  throw std::runtime_error("NullWeighting strategy cannot be used to evaluate weights.");
}
 
//-------------------------------------------------------------------------
// Gaussian 2D Weighting Implementations
//-------------------------------------------------------------------------
 
GaussianWeightingnD::GaussianWeightingnD(double cutOff, double sigma) : WeightingStrategy(cutOff) {
  if (cutOff < 0) {
    throw std::invalid_argument("GassianWeighting 1D expects unsigned cutOff input");
  }
  if (sigma < 0) {
    throw std::invalid_argument("GassianWeighting 1D expects unsigned standard deviation input");
  }
 
  m_twiceSigmaSquared = 2 * sigma * sigma;
}
 
double GaussianWeightingnD::weightAt(const Mantid::Kernel::V3D &distance) {
  /*
  distance.norm() = r
  r/R provides normalisation
  */
  double normalisedDistance = distance.norm() / m_cutOff; // Ensures 1 at the edges and zero in the
                                                          // center no matter what the units are
  return calculateGaussian(normalisedDistance * normalisedDistance);
}
 
double GaussianWeightingnD::weightAt(const double &adjX, const double &ix, const double &adjY, const double &iy) {
  double normalisedDistanceSq = (ix * ix + iy * iy) / (adjX * adjX + adjY * adjY);
  return calculateGaussian(normalisedDistanceSq);
}
 
inline double GaussianWeightingnD::calculateGaussian(const double normalisedDistanceSq) {
  return std::exp(-normalisedDistanceSq / m_twiceSigmaSquared);
}
 
} // namespace Mantid::Algorithms