/**
* Rebin the input quadrilateral to the output grid
* @param inputQ The input polygon
* @param inputWS The input workspace containing the input intensity values
* @param i The index in the vertical axis direction that inputQ references
* @param j The index in the horizontal axis direction that inputQ references
* @param outputWS A pointer to the output workspace that accumulates the data
* @param verticalAxis A vector containing the output vertical axis bin boundaries
*/
void Rebin2D::rebinToFractionalOutput(const Geometry::Quadrilateral & inputQ,
MatrixWorkspace_const_sptr inputWS,
const size_t i, const size_t j,
RebinnedOutput_sptr outputWS,
const std::vector<double> & verticalAxis)
{
const MantidVec & X = outputWS->readX(0);
size_t qstart(0), qend(verticalAxis.size()-1), en_start(0), en_end(X.size() - 1);
if( !getIntersectionRegion(outputWS, verticalAxis, inputQ, qstart, qend, en_start, en_end)) return;
for( size_t qi = qstart; qi < qend; ++qi )
{
const double vlo = verticalAxis[qi];
const double vhi = verticalAxis[qi+1];
for( size_t ei = en_start; ei < en_end; ++ei )
{
const V2D ll(X[ei], vlo);
const V2D lr(X[ei+1], vlo);
const V2D ur(X[ei+1], vhi);
const V2D ul(X[ei], vhi);
const Quadrilateral outputQ(ll, lr, ur, ul);
double yValue = inputWS->readY(i)[j];
if (boost::math::isnan(yValue))
{
continue;
}
try
{
ConvexPolygon overlap = intersectionByLaszlo(outputQ, inputQ);
const double weight = overlap.area()/inputQ.area();
yValue *= weight;
double eValue = inputWS->readE(i)[j] * weight;
const double overlapWidth = overlap.largestX() - overlap.smallestX();
// Don't do the overlap removal if already RebinnedOutput.
// This wreaks havoc on the data.
if(inputWS->isDistribution() && inputWS->id() != "RebinnedOutput")
{
yValue *= overlapWidth;
eValue *= overlapWidth;
}
eValue *= eValue;
PARALLEL_CRITICAL(overlap)
{
outputWS->dataY(qi)[ei] += yValue;
outputWS->dataE(qi)[ei] += eValue;
outputWS->dataF(qi)[ei] += weight;
}
}
catch(Geometry::NoIntersectionException &)
{}
}
}
}
/** Creates the output workspace, setting the axes according to the input binning parameters
* @param[in] inputWorkspace The input workspace
* @param[in] binParams The bin parameters from the user
* @param[out] newAxis The 'vertical' axis defined by the given parameters
* @return A pointer to the newly-created workspace
*/
RebinnedOutput_sptr SofQW3::setUpOutputWorkspace(API::MatrixWorkspace_const_sptr inputWorkspace,
const std::vector<double> & binParams, std::vector<double>& newAxis)
{
// Create vector to hold the new X axis values
MantidVecPtr xAxis;
xAxis.access() = inputWorkspace->readX(0);
const int xLength = static_cast<int>(xAxis->size());
// Create a vector to temporarily hold the vertical ('y') axis and populate that
const int yLength = static_cast<int>(VectorHelper::createAxisFromRebinParams(binParams,newAxis));
// Create the output workspace
MatrixWorkspace_sptr temp = WorkspaceFactory::Instance().create("RebinnedOutput", yLength - 1, xLength, xLength - 1);
RebinnedOutput_sptr outputWorkspace = boost::static_pointer_cast<RebinnedOutput>(temp);
WorkspaceFactory::Instance().initializeFromParent(inputWorkspace,
outputWorkspace, true);
// Create a numeric axis to replace the default vertical one
Axis* const verticalAxis = new NumericAxis(yLength);
outputWorkspace->replaceAxis(1, verticalAxis);
// Now set the axis values
for (int i = 0; i < yLength - 1; ++i)
{
outputWorkspace->setX(i, xAxis);
verticalAxis->setValue(i, newAxis[i]);
}
// One more to set on the 'y' axis
verticalAxis->setValue(yLength - 1, newAxis[yLength - 1]);
// Set the axis units
verticalAxis->unit() = UnitFactory::Instance().create("MomentumTransfer");
verticalAxis->title() = "|Q|";
// Set the X axis title (for conversion to MD)
outputWorkspace->getAxis(0)->title() = "Energy transfer";
return outputWorkspace;
}
/**
* Execution path for NormalisedPolygon Rebinning
* @param inputWS : Workspace to be rebinned
* @param vertexes : TableWorkspace for debugging purposes
* @param dumpVertexes : determines whether vertexes will be written to for
* debugging purposes or not
* @param outputDimensions : used for the column headings for Dump Vertexes
*/
MatrixWorkspace_sptr ReflectometryTransform::executeNormPoly(
MatrixWorkspace_const_sptr inputWS,
boost::shared_ptr<Mantid::DataObjects::TableWorkspace> &vertexes,
bool dumpVertexes, std::string outputDimensions) const {
MatrixWorkspace_sptr temp = WorkspaceFactory::Instance().create(
"RebinnedOutput", m_d1NumBins, m_d0NumBins, m_d0NumBins);
RebinnedOutput_sptr outWS = boost::static_pointer_cast<RebinnedOutput>(temp);
const double widthD0 = (m_d0Max - m_d0Min) / double(m_d0NumBins);
const double widthD1 = (m_d1Max - m_d1Min) / double(m_d1NumBins);
std::vector<double> xBinsVec;
std::vector<double> zBinsVec;
VectorHelper::createAxisFromRebinParams({m_d1Min, widthD1, m_d1Max},
zBinsVec);
VectorHelper::createAxisFromRebinParams({m_d0Min, widthD0, m_d0Max},
xBinsVec);
// Put the correct bin boundaries into the workspace
auto verticalAxis = new BinEdgeAxis(zBinsVec);
outWS->replaceAxis(1, verticalAxis);
for (size_t i = 0; i < zBinsVec.size() - 1; ++i)
outWS->setX(i, xBinsVec);
verticalAxis->title() = m_d1Label;
// Prepare the required theta values
DetectorAngularCache cache = initAngularCaches(inputWS.get());
m_theta = cache.thetas;
m_thetaWidths = cache.thetaWidths;
const size_t nHistos = inputWS->getNumberHistograms();
const size_t nBins = inputWS->blocksize();
// Holds the spectrum-detector mapping
std::vector<specnum_t> specNumberMapping;
std::vector<detid_t> detIDMapping;
// Create a table for the output if we want to debug vertex positioning
addColumnHeadings(vertexes, outputDimensions);
for (size_t i = 0; i < nHistos; ++i) {
IDetector_const_sptr detector = inputWS->getDetector(i);
if (!detector || detector->isMasked() || detector->isMonitor()) {
continue;
}
// Compute polygon points
const double theta = m_theta[i];
const double thetaWidth = m_thetaWidths[i];
const double thetaHalfWidth = 0.5 * thetaWidth;
const double thetaLower = theta - thetaHalfWidth;
const double thetaUpper = theta + thetaHalfWidth;
const MantidVec &X = inputWS->readX(i);
const MantidVec &Y = inputWS->readY(i);
const MantidVec &E = inputWS->readE(i);
for (size_t j = 0; j < nBins; ++j) {
const double lamLower = X[j];
const double lamUpper = X[j + 1];
const double signal = Y[j];
const double error = E[j];
auto inputQ =
m_calculator->createQuad(lamUpper, lamLower, thetaUpper, thetaLower);
FractionalRebinning::rebinToFractionalOutput(inputQ, inputWS, i, j, outWS,
zBinsVec);
// Find which qy bin this point lies in
const auto qIndex =
std::upper_bound(zBinsVec.begin(), zBinsVec.end(), inputQ[0].Y()) -
zBinsVec.begin();
if (qIndex != 0 && qIndex < static_cast<int>(zBinsVec.size())) {
// Add this spectra-detector pair to the mapping
specNumberMapping.push_back(
outWS->getSpectrum(qIndex - 1).getSpectrumNo());
detIDMapping.push_back(detector->getID());
}
// Debugging
if (dumpVertexes) {
writeRow(vertexes, inputQ[0], i, j, signal, error);
writeRow(vertexes, inputQ[1], i, j, signal, error);
writeRow(vertexes, inputQ[2], i, j, signal, error);
writeRow(vertexes, inputQ[3], i, j, signal, error);
}
}
}
outWS->finalize();
FractionalRebinning::normaliseOutput(outWS, inputWS);
// Set the output spectrum-detector mapping
SpectrumDetectorMapping outputDetectorMap(specNumberMapping, detIDMapping);
outWS->updateSpectraUsing(outputDetectorMap);
outWS->getAxis(0)->title() = m_d0Label;
outWS->setYUnit("");
outWS->setYUnitLabel("Intensity");
return outWS;
}
/**
* This function handles the logic for summing RebinnedOutput workspaces.
* @param outputWorkspace the workspace to hold the summed input
* @param progress the progress indicator
* @param numSpectra
* @param numMasked
* @param numZeros
*/
void SumSpectra::doRebinnedOutput(MatrixWorkspace_sptr outputWorkspace,
Progress &progress, size_t &numSpectra,
size_t &numMasked, size_t &numZeros) {
// Get a copy of the input workspace
MatrixWorkspace_sptr temp = getProperty("InputWorkspace");
// First, we need to clean the input workspace for nan's and inf's in order
// to treat the data correctly later. This will create a new private
// workspace that will be retrieved as mutable.
IAlgorithm_sptr alg = this->createChildAlgorithm("ReplaceSpecialValues");
alg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", temp);
std::string outName = "_" + temp->getName() + "_clean";
alg->setProperty("OutputWorkspace", outName);
alg->setProperty("NaNValue", 0.0);
alg->setProperty("NaNError", 0.0);
alg->setProperty("InfinityValue", 0.0);
alg->setProperty("InfinityError", 0.0);
alg->executeAsChildAlg();
MatrixWorkspace_sptr localworkspace = alg->getProperty("OutputWorkspace");
// Transform to real workspace types
RebinnedOutput_sptr inWS =
boost::dynamic_pointer_cast<RebinnedOutput>(localworkspace);
RebinnedOutput_sptr outWS =
boost::dynamic_pointer_cast<RebinnedOutput>(outputWorkspace);
// Get references to the output workspaces's data vectors
ISpectrum *outSpec = outputWorkspace->getSpectrum(0);
MantidVec &YSum = outSpec->dataY();
MantidVec &YError = outSpec->dataE();
MantidVec &FracSum = outWS->dataF(0);
MantidVec Weight;
std::vector<size_t> nZeros;
if (m_calculateWeightedSum) {
Weight.assign(YSum.size(), 0);
nZeros.assign(YSum.size(), 0);
}
numSpectra = 0;
numMasked = 0;
numZeros = 0;
// Loop over spectra
std::set<int>::iterator it;
// for (int i = m_minSpec; i <= m_maxSpec; ++i)
for (it = m_indices.begin(); it != m_indices.end(); ++it) {
int i = *it;
// Don't go outside the range.
if ((i >= m_numberOfSpectra) || (i < 0)) {
g_log.error() << "Invalid index " << i
<< " was specified. Sum was aborted.\n";
break;
}
try {
// Get the detector object for this spectrum
Geometry::IDetector_const_sptr det = localworkspace->getDetector(i);
// Skip monitors, if the property is set to do so
if (!m_keepMonitors && det->isMonitor())
continue;
// Skip masked detectors
if (det->isMasked()) {
numMasked++;
continue;
}
} catch (...) {
// if the detector not found just carry on
}
numSpectra++;
// Retrieve the spectrum into a vector
const MantidVec &YValues = localworkspace->readY(i);
const MantidVec &YErrors = localworkspace->readE(i);
const MantidVec &FracArea = inWS->readF(i);
if (m_calculateWeightedSum) {
for (int k = 0; k < this->m_yLength; ++k) {
if (YErrors[k] != 0) {
double errsq = YErrors[k] * YErrors[k] * FracArea[k] * FracArea[k];
YError[k] += errsq;
Weight[k] += 1. / errsq;
YSum[k] += YValues[k] * FracArea[k] / errsq;
FracSum[k] += FracArea[k];
} else {
nZeros[k]++;
FracSum[k] += FracArea[k];
}
}
} else {
for (int k = 0; k < this->m_yLength; ++k) {
YSum[k] += YValues[k] * FracArea[k];
YError[k] += YErrors[k] * YErrors[k] * FracArea[k] * FracArea[k];
FracSum[k] += FracArea[k];
}
}
// Map all the detectors onto the spectrum of the output
outSpec->addDetectorIDs(localworkspace->getSpectrum(i)->getDetectorIDs());
progress.report();
}
if (m_calculateWeightedSum) {
numZeros = 0;
for (size_t i = 0; i < Weight.size(); i++) {
if (nZeros[i] == 0)
YSum[i] *= double(numSpectra) / Weight[i];
else
numZeros += nZeros[i];
}
}
// Create the correct representation
outWS->finalize();
}
/**
* Execute the algorithm.
*/
void SofQW3::exec()
{
MatrixWorkspace_sptr inputWS = getProperty("InputWorkspace");
// Do the full check for common binning
if( !WorkspaceHelpers::commonBoundaries(inputWS) )
{
throw std::invalid_argument("The input workspace must have common binning across all spectra");
}
RebinnedOutput_sptr outputWS = this->setUpOutputWorkspace(inputWS,
getProperty("QAxisBinning"),
m_Qout);
g_log.debug() << "Workspace type: " << outputWS->id() << std::endl;
setProperty("OutputWorkspace", outputWS);
const size_t nEnergyBins = inputWS->blocksize();
const size_t nHistos = inputWS->getNumberHistograms();
// Progress reports & cancellation
const size_t nreports(nHistos * nEnergyBins);
m_progress = boost::shared_ptr<API::Progress>(new API::Progress(this, 0.0,
1.0,
nreports));
// Compute input caches
this->initCachedValues(inputWS);
std::vector<double> par = inputWS->getInstrument()->getNumberParameter("detector-neighbour-offset");
if (par.empty())
{
// Index theta cache
this->initThetaCache(inputWS);
}
else
{
g_log.debug() << "Offset: " << par[0] << std::endl;
this->m_detNeighbourOffset = static_cast<int>(par[0]);
this->getValuesAndWidths(inputWS);
}
const MantidVec & X = inputWS->readX(0);
PARALLEL_FOR2(inputWS, outputWS)
for (int64_t i = 0; i < static_cast<int64_t>(nHistos); ++i) // signed for openmp
{
PARALLEL_START_INTERUPT_REGION
DetConstPtr detector = inputWS->getDetector(i);
if (detector->isMasked() || detector->isMonitor())
{
continue;
}
double theta = this->m_theta[i];
double phi = 0.0;
double thetaWidth = 0.0;
double phiWidth = 0.0;
// Non-PSD mode
if (par.empty())
{
thetaWidth = this->m_thetaWidth;
}
// PSD mode
else
{
phi = this->m_phi[i];
thetaWidth = this->m_thetaWidths[i];
phiWidth = this->m_phiWidths[i];
}
double thetaHalfWidth = 0.5 * thetaWidth;
double phiHalfWidth = 0.5 * phiWidth;
const double thetaLower = theta - thetaHalfWidth;
const double thetaUpper = theta + thetaHalfWidth;
const double phiLower = phi - phiHalfWidth;
const double phiUpper = phi + phiHalfWidth;
const double efixed = this->getEFixed(detector);
for(size_t j = 0; j < nEnergyBins; ++j)
{
m_progress->report("Computing polygon intersections");
// For each input polygon test where it intersects with
// the output grid and assign the appropriate weights of Y/E
const double dE_j = X[j];
const double dE_jp1 = X[j+1];
const V2D ll(dE_j, this->calculateQ(efixed, dE_j, thetaLower, phiLower));
const V2D lr(dE_jp1, this->calculateQ(efixed, dE_jp1, thetaLower, phiLower));
const V2D ur(dE_jp1, this->calculateQ(efixed, dE_jp1, thetaUpper, phiUpper));
const V2D ul(dE_j, this->calculateQ(efixed, dE_j, thetaUpper, phiUpper));
Quadrilateral inputQ = Quadrilateral(ll, lr, ur, ul);
this->rebinToFractionalOutput(inputQ, inputWS, i, j, outputWS, m_Qout);
}
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
outputWS->finalize();
this->normaliseOutput(outputWS, inputWS);
}
/**
* This function handles the logic for summing RebinnedOutput workspaces.
* @param outputWorkspace the workspace to hold the summed input
* @param progress the progress indicator
* @param numSpectra
* @param numMasked
* @param numZeros
*/
void SumSpectra::doRebinnedOutput(MatrixWorkspace_sptr outputWorkspace,
Progress &progress, size_t &numSpectra,
size_t &numMasked, size_t &numZeros) {
// Get a copy of the input workspace
MatrixWorkspace_sptr in_ws = getProperty("InputWorkspace");
// First, we need to clean the input workspace for nan's and inf's in order
// to treat the data correctly later. This will create a new private
// workspace that will be retrieved as mutable.
auto localworkspace = replaceSpecialValues(in_ws);
// Transform to real workspace types
RebinnedOutput_sptr inWS =
boost::dynamic_pointer_cast<RebinnedOutput>(localworkspace);
RebinnedOutput_sptr outWS =
boost::dynamic_pointer_cast<RebinnedOutput>(outputWorkspace);
// Get references to the output workspaces's data vectors
auto &outSpec = outputWorkspace->getSpectrum(0);
auto &YSum = outSpec.mutableY();
auto &YError = outSpec.mutableE();
auto &FracSum = outWS->dataF(0);
std::vector<double> Weight;
std::vector<size_t> nZeros;
if (m_calculateWeightedSum) {
Weight.assign(YSum.size(), 0);
nZeros.assign(YSum.size(), 0);
}
numSpectra = 0;
numMasked = 0;
numZeros = 0;
const auto &spectrumInfo = localworkspace->spectrumInfo();
// Loop over spectra
for (const auto i : m_indices) {
// Don't go outside the range.
if ((i >= m_numberOfSpectra) || (i < 0)) {
g_log.error() << "Invalid index " << i
<< " was specified. Sum was aborted.\n";
break;
}
if (spectrumInfo.hasDetectors(i)) {
// Skip monitors, if the property is set to do so
if (!m_keepMonitors && spectrumInfo.isMonitor(i))
continue;
// Skip masked detectors
if (spectrumInfo.isMasked(i)) {
numMasked++;
continue;
}
}
numSpectra++;
// Retrieve the spectrum into a vector
const auto &YValues = localworkspace->y(i);
const auto &YErrors = localworkspace->e(i);
const auto &FracArea = inWS->readF(i);
if (m_calculateWeightedSum) {
for (int k = 0; k < this->m_yLength; ++k) {
if (YErrors[k] != 0) {
double errsq = YErrors[k] * YErrors[k] * FracArea[k] * FracArea[k];
YError[k] += errsq;
Weight[k] += 1. / errsq;
YSum[k] += YValues[k] * FracArea[k] / errsq;
FracSum[k] += FracArea[k];
} else {
nZeros[k]++;
FracSum[k] += FracArea[k];
}
}
} else {
for (int k = 0; k < this->m_yLength; ++k) {
YSum[k] += YValues[k] * FracArea[k];
YError[k] += YErrors[k] * YErrors[k] * FracArea[k] * FracArea[k];
FracSum[k] += FracArea[k];
}
}
// Map all the detectors onto the spectrum of the output
outSpec.addDetectorIDs(localworkspace->getSpectrum(i).getDetectorIDs());
progress.report();
}
if (m_calculateWeightedSum) {
numZeros = 0;
for (size_t i = 0; i < Weight.size(); i++) {
if (numSpectra > nZeros[i])
YSum[i] *= double(numSpectra - nZeros[i]) / Weight[i];
if (nZeros[i] != 0)
numZeros += nZeros[i];
}
}
// Create the correct representation
outWS->finalize();
}
