RebinnedOutput.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 "MantidDataObjects/RebinnedOutput.h"
 
#include "MantidAPI/WorkspaceFactory.h"
 
#include <algorithm>
#include <iterator>
#include <sstream>
 
namespace Mantid::DataObjects {
 
DECLARE_WORKSPACE(RebinnedOutput)
 
 
const std::string RebinnedOutput::id() const { return "RebinnedOutput"; }
 
void RebinnedOutput::init(const std::size_t &NVectors, const std::size_t &XLength, const std::size_t &YLength) {
  Workspace2D::init(NVectors, XLength, YLength);
  std::size_t nHist = this->getNumberHistograms();
  this->fracArea.resize(nHist);
  for (std::size_t i = 0; i < nHist; ++i) {
    this->fracArea[i].resize(YLength);
  }
}
 
void RebinnedOutput::init(const HistogramData::Histogram &histogram) {
  Workspace2D::init(histogram);
  std::size_t nHist = this->getNumberHistograms();
  this->fracArea.resize(nHist);
  for (std::size_t i = 0; i < nHist; ++i) {
    this->fracArea[i].resize(histogram.size());
  }
}
 
MantidVec &RebinnedOutput::dataF(const std::size_t index) { return this->fracArea[index]; }
 
const MantidVec &RebinnedOutput::dataF(const std::size_t index) const { return this->fracArea[index]; }
 
const MantidVec &RebinnedOutput::readF(const std::size_t index) const { return this->fracArea[index]; }
 
void RebinnedOutput::setF(const std::size_t index, const MantidVecPtr &F) { this->fracArea[index] = *F; }
 
void RebinnedOutput::scaleF(const double scale) {
  std::size_t nHist = this->getNumberHistograms();
  for (std::size_t i = 0; i < nHist; ++i) {
    MantidVec &frac = this->dataF(i);
    std::transform(frac.begin(), frac.end(), frac.begin(), [scale](double x) { return scale * x; });
  }
}
 
bool RebinnedOutput::nonZeroF() const {
 
  // Checks that the fractions are not all zeros.
  auto nHist = static_cast<int>(this->getNumberHistograms());
  bool frac_all_zeros = true;
  for (int i = 0; i < nHist; ++i) {
    const MantidVec &frac = this->readF(i);
    if (std::accumulate(frac.begin(), frac.end(), 0.) != 0) {
      frac_all_zeros = false;
      break;
    }
  }
  return !frac_all_zeros;
}
 
void RebinnedOutput::finalize(bool hasSqrdErrs) {
  if (m_finalized && hasSqrdErrs == m_hasSqrdErrs)
    return;
 
  // Checks that the fractions are not all zeros.
  if (!this->nonZeroF())
    return;
 
  // Fix the squared error representation before returning
  auto nHist = static_cast<int>(this->getNumberHistograms());
  if (m_finalized) {
    PARALLEL_FOR_IF(Kernel::threadSafe(*this))
    for (int i = 0; i < nHist; ++i) {
      MantidVec &err = this->dataE(i);
      MantidVec &frac = this->dataF(i);
      if (hasSqrdErrs) {
        std::transform(err.begin(), err.end(), frac.begin(), err.begin(), std::divides<double>());
      } else {
        std::transform(err.begin(), err.end(), frac.begin(), err.begin(), std::multiplies<double>());
      }
    }
 
    // Sets flag so subsequent algorithms know to correctly treat data
    m_hasSqrdErrs = hasSqrdErrs;
    return;
  }
 
  PARALLEL_FOR_IF(Kernel::threadSafe(*this))
  for (int i = 0; i < nHist; ++i) {
    MantidVec &data = this->dataY(i);
    MantidVec &err = this->dataE(i);
    MantidVec &frac = this->dataF(i);
    std::transform(data.begin(), data.end(), frac.begin(), data.begin(), std::divides<double>());
    std::transform(err.begin(), err.end(), frac.begin(), err.begin(), std::divides<double>());
    if (hasSqrdErrs) {
      std::transform(err.begin(), err.end(), frac.begin(), err.begin(), std::divides<double>());
    }
  }
  // Sets flags so subsequent algorithms know to correctly treat data
  m_finalized = true;
  m_hasSqrdErrs = hasSqrdErrs;
}
 
void RebinnedOutput::unfinalize() {
  if (!m_finalized || !this->nonZeroF())
    return;
 
  auto nHist = static_cast<int>(this->getNumberHistograms());
  PARALLEL_FOR_IF(Kernel::threadSafe(*this))
  for (int i = 0; i < nHist; ++i) {
    MantidVec &data = this->dataY(i);
    MantidVec &err = this->dataE(i);
    MantidVec &frac = this->dataF(i);
    std::transform(data.begin(), data.end(), frac.begin(), data.begin(), std::multiplies<double>());
    std::transform(err.begin(), err.end(), frac.begin(), err.begin(), std::multiplies<double>());
    if (this->m_hasSqrdErrs) {
      std::transform(err.begin(), err.end(), frac.begin(), err.begin(), std::multiplies<double>());
    }
  }
  // Sets flag so subsequent algorithms know to correctly treat data
  m_finalized = false;
}
 
} // namespace Mantid::DataObjects