SmoothNeighbours.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/Algorithm.h"
#include "MantidAlgorithms/DllConfig.h"
#include "MantidAlgorithms/WeightingStrategy.h"
#include "MantidDataObjects/EventWorkspace_fwd.h"
#include "MantidGeometry/IDTypes.h"
#include "MantidKernel/V3D.h"
 
namespace Mantid {
namespace Algorithms {
using SpectraDistanceMap = std::map<specnum_t, Mantid::Kernel::V3D>;
 
/*
Filters spectra detector list by radius.
*/
class MANTID_ALGORITHMS_DLL RadiusFilter {
public:
  RadiusFilter(double cutoff) : m_cutoff(cutoff) {
    if (cutoff < 0) {
      throw std::invalid_argument("RadiusFilter - Cannot have a negative cutoff.");
    }
  }
  SpectraDistanceMap apply(SpectraDistanceMap &unfiltered) const {
    SpectraDistanceMap neighbSpectra;
    double cutoff{m_cutoff};
    std::copy_if(unfiltered.begin(), unfiltered.end(), std::inserter(neighbSpectra, neighbSpectra.end()),
                 [cutoff](const std::pair<specnum_t, Mantid::Kernel::V3D> &spectraDistance) {
                   return spectraDistance.second.norm() <= cutoff;
                 });
    return neighbSpectra;
  }
 
private:
  double m_cutoff;
};
 
class MANTID_ALGORITHMS_DLL SmoothNeighbours final : public API::Algorithm {
public:
  SmoothNeighbours();
  const std::string name() const override { return "SmoothNeighbours"; }
  const std::string summary() const override {
    return "Perform a moving-average smoothing by summing spectra of nearest "
           "neighbours over the face of detectors.";
  }
 
  int version() const override { return (1); }
  const std::vector<std::string> seeAlso() const override { return {"SmoothData"}; }
  const std::string category() const override { return "Transforms\\Smoothing"; }
 
private:
  // Overridden Algorithm methods
  void init() override;
  void exec() override;
 
  void execWorkspace2D();
  void execEvent(Mantid::DataObjects::EventWorkspace_sptr &ws);
  void findNeighboursRectangular();
  void findNeighboursUbiquitous();
 
  void setWeightingStrategy(const std::string &strategyName, double &cutOff);
  double translateToMeters(const std::string &radiusUnits, const double &enteredRadius) const;
 
  void setupNewInstrument(API::MatrixWorkspace &outWS) const;
 
  void spreadPixels(const API::MatrixWorkspace_sptr &outWS);
 
  int m_adjX = 0;
  int m_adjY = 0;
  int m_edge = 0;
  double m_radius = 0.0;
  int m_nNeighbours = 0;
  std::unique_ptr<WeightingStrategy> m_weightedSum;
  bool m_preserveEvents = false;
  bool m_expandSumAllPixels = false;
  size_t m_outWI = 0;
  Mantid::API::MatrixWorkspace_sptr m_inWS;
  using weightedNeighbour = std::pair<size_t, double>;
  std::vector<std::vector<weightedNeighbour>> m_neighbours;
  std::unique_ptr<Mantid::API::Progress> m_progress = nullptr;
};
 
} // namespace Algorithms
} // namespace Mantid