MuonPairAsymmetryCalculator.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 "MantidWorkflowAlgorithms/MuonPairAsymmetryCalculator.h"
 
using Mantid::API::AlgorithmManager;
using Mantid::API::IAlgorithm_sptr;
using Mantid::API::MatrixWorkspace_sptr;
using Mantid::API::Workspace_sptr;
 
namespace Mantid::WorkflowAlgorithms {
 
//----------------------------------------------------------------------------------------------
MuonPairAsymmetryCalculator::MuonPairAsymmetryCalculator(const API::WorkspaceGroup_sptr &inputWS,
                                                         const std::vector<int> &summedPeriods,
                                                         const std::vector<int> &subtractedPeriods,
                                                         const int firstPairIndex, const int secondPairIndex,
                                                         const double alpha)
    : IMuonAsymmetryCalculator(inputWS, summedPeriods, subtractedPeriods), m_alpha(alpha),
      m_firstPairIndex(firstPairIndex), m_secondPairIndex(secondPairIndex) {}
 
MatrixWorkspace_sptr MuonPairAsymmetryCalculator::calculate() const {
  MatrixWorkspace_sptr outWS;
 
  int numPeriods = m_inputWS->getNumberOfEntries();
  if (numPeriods > 1) {
 
    auto summedWS = sumPeriods(m_summedPeriods);
    auto subtractedWS = sumPeriods(m_subtractedPeriods);
 
    // Summed periods asymmetry
    MatrixWorkspace_sptr asymSummedPeriods = asymmetryCalc(summedWS);
 
    if (!m_subtractedPeriods.empty()) {
      // Subtracted periods asymmetry
      MatrixWorkspace_sptr asymSubtractedPeriods = asymmetryCalc(subtractedWS);
      // Now subtract
      outWS = subtractWorkspaces(asymSummedPeriods, asymSubtractedPeriods);
    } else {
      outWS = asymSummedPeriods;
    }
 
  } else {
    outWS = asymmetryCalc(m_inputWS->getItem(0));
  }
 
  return outWS;
}
 
MatrixWorkspace_sptr MuonPairAsymmetryCalculator::asymmetryCalc(const Workspace_sptr &inputWS) const {
  MatrixWorkspace_sptr outWS;
 
  if (inputWS) {
    // Pair indices as vectors
    std::vector<int> fwd(1, m_firstPairIndex + 1);
    std::vector<int> bwd(1, m_secondPairIndex + 1);
 
    auto alg = AlgorithmManager::Instance().create("AsymmetryCalc");
    alg->setChild(true);
    alg->setProperty("InputWorkspace", inputWS);
    alg->setProperty("ForwardSpectra", fwd);
    alg->setProperty("BackwardSpectra", bwd);
    alg->setProperty("Alpha", m_alpha);
    alg->setProperty("OutputWorkspace", "__NotUsed__");
    alg->execute();
    outWS = alg->getProperty("OutputWorkspace");
  }
 
  return outWS;
}
 
} // namespace Mantid::WorkflowAlgorithms