MatrixWorkspace_sptr
PolarizationCorrection::copyShapeAndFill(MatrixWorkspace_sptr &base,
const double &value) {
MatrixWorkspace_sptr wsTemplate = WorkspaceFactory::Instance().create(base);
// Copy the x-array across to the new workspace.
for (size_t i = 0; i < wsTemplate->getNumberHistograms(); ++i) {
wsTemplate->setSharedX(i, base->sharedX(i));
}
auto zeroed = this->multiply(wsTemplate, 0);
auto filled = this->add(zeroed, value);
return filled;
}
/// Execute the algorithm in case of a histogrammed data.
void ExtractSpectra::execHistogram() {
// Retrieve and validate the input properties
this->checkProperties();
// Create the output workspace
MatrixWorkspace_sptr outputWorkspace = WorkspaceFactory::Instance().create(
m_inputWorkspace, m_workspaceIndexList.size(), m_maxX - m_minX,
m_maxX - m_minX - m_histogram);
outputWorkspace->setIndexInfo(
Indexing::extract(m_inputWorkspace->indexInfo(), m_workspaceIndexList));
// If this is a Workspace2D, get the spectra axes for copying in the spectraNo
// later
Axis *inAxis1(nullptr);
TextAxis *outTxtAxis(nullptr);
NumericAxis *outNumAxis(nullptr);
if (m_inputWorkspace->axes() > 1) {
inAxis1 = m_inputWorkspace->getAxis(1);
auto outAxis1 = outputWorkspace->getAxis(1);
outTxtAxis = dynamic_cast<TextAxis *>(outAxis1);
if (!outTxtAxis)
outNumAxis = dynamic_cast<NumericAxis *>(outAxis1);
}
cow_ptr<HistogramData::HistogramX> newX(nullptr);
if (m_commonBoundaries) {
auto &oldX = m_inputWorkspace->x(m_workspaceIndexList.front());
newX = make_cow<HistogramData::HistogramX>(oldX.begin() + m_minX,
oldX.begin() + m_maxX);
}
bool doCrop = ((m_minX != 0) || (m_maxX != m_inputWorkspace->x(0).size()));
Progress prog(this, 0.0, 1.0, (m_workspaceIndexList.size()));
// Loop over the required workspace indices, copying in the desired bins
for (int j = 0; j < static_cast<int>(m_workspaceIndexList.size()); ++j) {
auto i = m_workspaceIndexList[j];
bool hasDx = m_inputWorkspace->hasDx(i);
// Preserve/restore sharing if X vectors are the same
if (m_commonBoundaries) {
outputWorkspace->setSharedX(j, newX);
if (hasDx) {
auto &oldDx = m_inputWorkspace->dx(i);
outputWorkspace->setSharedDx(
j,
make_cow<HistogramData::HistogramDx>(
oldDx.begin() + m_minX, oldDx.begin() + m_maxX - m_histogram));
}
} else {
// Safe to just copy whole vector 'cos can't be cropping in X if not
// common
outputWorkspace->setSharedX(j, m_inputWorkspace->sharedX(i));
outputWorkspace->setSharedDx(j, m_inputWorkspace->sharedDx(i));
}
if (doCrop) {
auto &oldY = m_inputWorkspace->y(i);
outputWorkspace->mutableY(j)
.assign(oldY.begin() + m_minX, oldY.begin() + (m_maxX - m_histogram));
auto &oldE = m_inputWorkspace->e(i);
outputWorkspace->mutableE(j)
.assign(oldE.begin() + m_minX, oldE.begin() + (m_maxX - m_histogram));
} else {
outputWorkspace->setSharedY(j, m_inputWorkspace->sharedY(i));
outputWorkspace->setSharedE(j, m_inputWorkspace->sharedE(i));
}
// copy over the axis entry for each spectrum, regardless of the type of
// axes present
if (inAxis1) {
if (outTxtAxis) {
outTxtAxis->setLabel(j, inAxis1->label(i));
} else if (outNumAxis) {
outNumAxis->setValue(j, inAxis1->operator()(i));
}
// spectra axis is implicit in workspace creation
}
if (!m_commonBoundaries)
this->cropRagged(outputWorkspace, static_cast<int>(i), j);
// Propagate bin masking if there is any
if (m_inputWorkspace->hasMaskedBins(i)) {
const MatrixWorkspace::MaskList &inputMasks =
m_inputWorkspace->maskedBins(i);
MatrixWorkspace::MaskList::const_iterator it;
for (it = inputMasks.begin(); it != inputMasks.end(); ++it) {
const size_t maskIndex = (*it).first;
if (maskIndex >= m_minX && maskIndex < m_maxX - m_histogram)
outputWorkspace->flagMasked(j, maskIndex - m_minX, (*it).second);
}
}
prog.report();
}
setProperty("OutputWorkspace", outputWorkspace);
}
/** Carries out the bin-by-bin normalization
* @param inputWorkspace The input workspace
* @param outputWorkspace The result workspace
*/
void NormaliseToMonitor::normaliseBinByBin(
const MatrixWorkspace_sptr &inputWorkspace,
MatrixWorkspace_sptr &outputWorkspace) {
EventWorkspace_sptr inputEvent =
boost::dynamic_pointer_cast<EventWorkspace>(inputWorkspace);
// Only create output workspace if different to input one
if (outputWorkspace != inputWorkspace) {
if (inputEvent) {
outputWorkspace = inputWorkspace->clone();
} else
outputWorkspace = create<MatrixWorkspace>(*inputWorkspace);
}
auto outputEvent =
boost::dynamic_pointer_cast<EventWorkspace>(outputWorkspace);
const auto &inputSpecInfo = inputWorkspace->spectrumInfo();
const auto &monitorSpecInfo = m_monitor->spectrumInfo();
const auto specLength = inputWorkspace->blocksize();
for (auto &workspaceIndex : m_workspaceIndexes) {
// Get hold of the monitor spectrum
const auto &monX = m_monitor->binEdges(workspaceIndex);
auto monY = m_monitor->counts(workspaceIndex);
auto monE = m_monitor->countStandardDeviations(workspaceIndex);
size_t timeIndex = 0;
if (m_scanInput)
timeIndex = monitorSpecInfo.spectrumDefinition(workspaceIndex)[0].second;
// Calculate the overall normalization just the once if bins are all
// matching
if (m_commonBins)
this->normalisationFactor(monX, monY, monE);
const size_t numHists = inputWorkspace->getNumberHistograms();
// Flag set when a division by 0 is found
bool hasZeroDivision = false;
Progress prog(this, 0.0, 1.0, numHists);
// Loop over spectra
PARALLEL_FOR_IF(
Kernel::threadSafe(*inputWorkspace, *outputWorkspace, *m_monitor))
for (int64_t i = 0; i < int64_t(numHists); ++i) {
PARALLEL_START_INTERUPT_REGION
prog.report();
const auto &specDef = inputSpecInfo.spectrumDefinition(i);
if (!spectrumDefinitionsMatchTimeIndex(specDef, timeIndex))
continue;
const auto &X = inputWorkspace->binEdges(i);
// If not rebinning, just point to our monitor spectra, otherwise create
// new vectors
auto Y = (m_commonBins ? monY : Counts(specLength));
auto E = (m_commonBins ? monE : CountStandardDeviations(specLength));
if (!m_commonBins) {
// ConvertUnits can give X vectors of all zeros - skip these, they
// cause
// problems
if (X.back() == 0.0 && X.front() == 0.0)
continue;
// Rebin the monitor spectrum to match the binning of the current data
// spectrum
VectorHelper::rebinHistogram(
monX.rawData(), monY.mutableRawData(), monE.mutableRawData(),
X.rawData(), Y.mutableRawData(), E.mutableRawData(), false);
// Recalculate the overall normalization factor
this->normalisationFactor(X, Y, E);
}
if (inputEvent) {
// --- EventWorkspace ---
EventList &outEL = outputEvent->getSpectrum(i);
outEL.divide(X.rawData(), Y.mutableRawData(), E.mutableRawData());
} else {
// --- Workspace2D ---
auto &YOut = outputWorkspace->mutableY(i);
auto &EOut = outputWorkspace->mutableE(i);
const auto &inY = inputWorkspace->y(i);
const auto &inE = inputWorkspace->e(i);
outputWorkspace->setSharedX(i, inputWorkspace->sharedX(i));
// The code below comes more or less straight out of Divide.cpp
for (size_t k = 0; k < specLength; ++k) {
// Get the input Y's
const double leftY = inY[k];
const double rightY = Y[k];
if (rightY == 0.0) {
hasZeroDivision = true;
}
// Calculate result and store in local variable to avoid overwriting
// original data if output workspace is same as one of the input
// ones
const double newY = leftY / rightY;
if (fabs(rightY) > 1.0e-12 && fabs(newY) > 1.0e-12) {
const double lhsFactor = (inE[k] < 1.0e-12 || fabs(leftY) < 1.0e-12)
? 0.0
: pow((inE[k] / leftY), 2);
const double rhsFactor =
E[k] < 1.0e-12 ? 0.0 : pow((E[k] / rightY), 2);
EOut[k] = std::abs(newY) * sqrt(lhsFactor + rhsFactor);
}
// Now store the result
YOut[k] = newY;
} // end Workspace2D case
} // end loop over current spectrum
PARALLEL_END_INTERUPT_REGION
} // end loop over spectra
PARALLEL_CHECK_INTERUPT_REGION
if (hasZeroDivision) {
g_log.warning() << "Division by zero in some of the bins.\n";
}
if (inputEvent)
outputEvent->clearMRU();
}
}
Workspace_sptr SeqDomainSpectrumCreator::createOutputWorkspace(
const std::string &baseName, IFunction_sptr function,
boost::shared_ptr<FunctionDomain> domain,
boost::shared_ptr<FunctionValues> values,
const std::string &outputWorkspacePropertyName) {
// don't need values, since the values need to be calculated spectrum by
// spectrum (see loop below).
UNUSED_ARG(values);
boost::shared_ptr<SeqDomain> seqDomain =
boost::dynamic_pointer_cast<SeqDomain>(domain);
if (!seqDomain) {
throw std::invalid_argument("CreateOutputWorkspace requires SeqDomain.");
}
if (!m_matrixWorkspace) {
throw std::invalid_argument("No MatrixWorkspace assigned. Cannot construct "
"proper output workspace.");
}
MatrixWorkspace_sptr outputWs = boost::dynamic_pointer_cast<MatrixWorkspace>(
WorkspaceFactory::Instance().create(m_matrixWorkspace));
// Assign y-values, taking into account masked detectors
for (size_t i = 0; i < seqDomain->getNDomains(); ++i) {
FunctionDomain_sptr localDomain;
FunctionValues_sptr localValues;
seqDomain->getDomainAndValues(i, localDomain, localValues);
function->function(*localDomain, *localValues);
boost::shared_ptr<FunctionDomain1DSpectrum> spectrumDomain =
boost::dynamic_pointer_cast<FunctionDomain1DSpectrum>(localDomain);
if (spectrumDomain) {
size_t wsIndex = spectrumDomain->getWorkspaceIndex();
auto &yValues = outputWs->mutableY(wsIndex);
for (size_t j = 0; j < yValues.size(); ++j) {
yValues[j] = localValues->getCalculated(j);
}
}
}
// Assign x-values on all histograms
for (size_t i = 0; i < m_matrixWorkspace->getNumberHistograms(); ++i) {
outputWs->setSharedX(i, m_matrixWorkspace->sharedX(i));
}
if (m_manager && !outputWorkspacePropertyName.empty()) {
declareProperty(
new WorkspaceProperty<MatrixWorkspace>(outputWorkspacePropertyName, "",
Kernel::Direction::Output),
"Result workspace");
m_manager->setPropertyValue(outputWorkspacePropertyName,
baseName + "Workspace");
m_manager->setProperty(outputWorkspacePropertyName, outputWs);
}
// If the input is a not an EventWorkspace and is a distrubution, then convert
// the output also to a distribution
if (!boost::dynamic_pointer_cast<Mantid::API::IEventWorkspace>(
m_matrixWorkspace)) {
if (m_matrixWorkspace->isDistribution()) {
outputWs->setDistribution(true);
}
}
return outputWs;
}
