/*
* Sum up all the unmasked detector pixels.
*
* @param rebinnedWS: workspace where all the wavelength bins have been grouped
*together
* @param sum: sum of all the unmasked detector pixels (counts)
* @param error: error on sum (counts)
* @param nPixels: number of unmasked detector pixels that contributed to sum
*/
void CalculateEfficiency::sumUnmaskedDetectors(MatrixWorkspace_sptr rebinnedWS,
double &sum, double &error,
int &nPixels) {
// Number of spectra
const int numberOfSpectra =
static_cast<int>(rebinnedWS->getNumberHistograms());
sum = 0.0;
error = 0.0;
nPixels = 0;
const auto &spectrumInfo = rebinnedWS->spectrumInfo();
for (int i = 0; i < numberOfSpectra; i++) {
progress(0.2 + 0.2 * i / numberOfSpectra, "Computing sensitivity");
// Skip if we have a monitor or if the detector is masked.
if (spectrumInfo.isMonitor(i) || spectrumInfo.isMasked(i))
continue;
// Retrieve the spectrum into a vector
auto &YValues = rebinnedWS->y(i);
auto &YErrors = rebinnedWS->e(i);
sum += YValues[0];
error += YErrors[0] * YErrors[0];
nPixels++;
}
g_log.debug() << "sumUnmaskedDetectors: unmasked pixels = " << nPixels
<< " from a total of " << numberOfSpectra << "\n";
error = std::sqrt(error);
}
/**
* This performs a similar operation to divide, but is a separate algorithm so
*that the correct spectra are used in the case of detector scans. This
*currently does not support event workspaces properly, but should be made to in
*the future.
*
* @param inputWorkspace The workspace with the spectra to divide by the monitor
* @param outputWorkspace The resulting workspace
*/
void NormaliseToMonitor::performHistogramDivision(
const MatrixWorkspace_sptr &inputWorkspace,
MatrixWorkspace_sptr &outputWorkspace) {
if (outputWorkspace != inputWorkspace)
outputWorkspace = inputWorkspace->clone();
size_t monitorWorkspaceIndex = 0;
Progress prog(this, 0.0, 1.0, m_workspaceIndexes.size());
const auto &specInfo = inputWorkspace->spectrumInfo();
for (const auto workspaceIndex : m_workspaceIndexes) {
// Errors propagated according to
// http://docs.mantidproject.org/nightly/concepts/ErrorPropagation.html#error-propagation
// This is similar to that in MantidAlgorithms::Divide
prog.report("Performing normalisation");
size_t timeIndex = 0;
if (m_scanInput)
timeIndex = specInfo.spectrumDefinition(workspaceIndex)[0].second;
const auto newYFactor =
1.0 / m_monitor->histogram(monitorWorkspaceIndex).y()[0];
const auto divisorError =
m_monitor->histogram(monitorWorkspaceIndex).e()[0];
const double yErrorFactor = pow(divisorError * newYFactor, 2);
monitorWorkspaceIndex++;
PARALLEL_FOR_IF(Kernel::threadSafe(*outputWorkspace))
for (int64_t i = 0; i < int64_t(outputWorkspace->getNumberHistograms());
++i) {
PARALLEL_START_INTERUPT_REGION
const auto &specDef = specInfo.spectrumDefinition(i);
if (!spectrumDefinitionsMatchTimeIndex(specDef, timeIndex))
continue;
auto hist = outputWorkspace->histogram(i);
auto &yValues = hist.mutableY();
auto &eValues = hist.mutableE();
for (size_t j = 0; j < yValues.size(); ++j) {
eValues[j] = newYFactor * sqrt(eValues[j] * eValues[j] +
yValues[j] * yValues[j] * yErrorFactor);
yValues[j] *= newYFactor;
}
outputWorkspace->setHistogram(i, hist);
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
}
}
/**
* Get the detector component. Use the name provided as a property as the basis
*for the lookup as a priority.
*
* Throws if the name is invalid.
* @param workspace : Workspace from instrument with detectors
* @param isPointDetector : True if this is a point detector. Used to guess a
*name.
* @return The component : The component object found.
*/
boost::shared_ptr<const Mantid::Geometry::IComponent>
SpecularReflectionAlgorithm::getDetectorComponent(
MatrixWorkspace_sptr workspace, const bool isPointDetector) const {
boost::shared_ptr<const IComponent> searchResult;
if (!isPropertyDefault("SpectrumNumbersOfDetectors")) {
const std::vector<int> spectrumNumbers =
this->getProperty("SpectrumNumbersOfDetectors");
const bool strictSpectrumChecking =
this->getProperty("StrictSpectrumChecking");
checkSpectrumNumbers(spectrumNumbers, strictSpectrumChecking, g_log);
auto specToWorkspaceIndex = workspace->getSpectrumToWorkspaceIndexMap();
DetectorGroup_sptr allDetectors = boost::make_shared<DetectorGroup>();
const auto &spectrumInfo = workspace->spectrumInfo();
for (auto index : spectrumNumbers) {
const size_t spectrumNumber{static_cast<size_t>(index)};
auto it = specToWorkspaceIndex.find(index);
if (it == specToWorkspaceIndex.end()) {
std::stringstream message;
message << "Spectrum number " << spectrumNumber
<< " does not exist in the InputWorkspace";
throw std::invalid_argument(message.str());
}
const size_t workspaceIndex = it->second;
auto detector = workspace->getDetector(workspaceIndex);
if (spectrumInfo.isMasked(workspaceIndex))
g_log.warning() << "Adding a detector (ID:" << detector->getID()
<< ") that is flagged as masked.\n";
allDetectors->addDetector(detector);
}
searchResult = allDetectors;
} else {
Mantid::Geometry::Instrument_const_sptr inst = workspace->getInstrument();
std::string componentToCorrect =
isPointDetector ? "point-detector" : "linedetector";
if (!isPropertyDefault("DetectorComponentName")) {
componentToCorrect = this->getPropertyValue("DetectorComponentName");
}
searchResult = inst->getComponentByName(componentToCorrect);
if (searchResult == nullptr) {
throw std::invalid_argument(componentToCorrect +
" does not exist. Check input properties.");
}
}
return searchResult;
}
void CalculateEfficiency::normalizeDetectors(MatrixWorkspace_sptr rebinnedWS,
MatrixWorkspace_sptr outputWS,
double sum, double error,
int nPixels, double min_eff,
double max_eff) {
// Number of spectra
const size_t numberOfSpectra = rebinnedWS->getNumberHistograms();
// Empty vector to store the pixels that outside the acceptable efficiency
// range
std::vector<size_t> dets_to_mask;
const auto &spectrumInfo = rebinnedWS->spectrumInfo();
for (size_t i = 0; i < numberOfSpectra; i++) {
const double currProgress =
0.4 +
0.2 * (static_cast<double>(i) / static_cast<double>(numberOfSpectra));
progress(currProgress, "Computing sensitivity");
// If this spectrum is masked, skip to the next one
if (spectrumInfo.isMasked(i))
continue;
// Retrieve the spectrum into a vector
auto &YIn = rebinnedWS->y(i);
auto &EIn = rebinnedWS->e(i);
auto &YOut = outputWS->mutableY(i);
auto &EOut = outputWS->mutableE(i);
// If this detector is a monitor, skip to the next one
if (spectrumInfo.isMonitor(i)) {
YOut[0] = 1.0;
EOut[0] = 0.0;
continue;
}
// Normalize counts to get relative efficiency
YOut[0] = nPixels / sum * YIn[0];
const double err_sum = YIn[0] / sum * error;
EOut[0] = nPixels / std::abs(sum) *
std::sqrt(EIn[0] * EIn[0] + err_sum * err_sum);
// Mask this detector if the signal is outside the acceptable band
if (!isEmpty(min_eff) && YOut[0] < min_eff)
dets_to_mask.push_back(i);
if (!isEmpty(max_eff) && YOut[0] > max_eff)
dets_to_mask.push_back(i);
}
g_log.debug() << "normalizeDetectors: Masked pixels outside the acceptable "
"efficiency range [" << min_eff << "," << max_eff
<< "] = " << dets_to_mask.size()
<< " from a total of non masked = " << nPixels
<< " (from a total number of spectra in the ws = "
<< numberOfSpectra << ")\n";
// If we identified pixels to be masked, mask them now
if (!dets_to_mask.empty()) {
// Mask detectors that were found to be outside the acceptable efficiency
// band
try {
IAlgorithm_sptr mask = createChildAlgorithm("MaskDetectors", 0.8, 0.9);
// First we mask detectors in the output workspace
mask->setProperty<MatrixWorkspace_sptr>("Workspace", outputWS);
mask->setProperty<std::vector<size_t>>("WorkspaceIndexList",
dets_to_mask);
mask->execute();
mask = createChildAlgorithm("MaskDetectors", 0.9, 1.0);
// Then we mask the same detectors in the input workspace
mask->setProperty<MatrixWorkspace_sptr>("Workspace", rebinnedWS);
mask->setProperty<std::vector<size_t>>("WorkspaceIndexList",
dets_to_mask);
mask->execute();
} catch (std::invalid_argument &err) {
std::stringstream e;
e << "Invalid argument to MaskDetectors Child Algorithm: " << err.what();
g_log.error(e.str());
} catch (std::runtime_error &err) {
std::stringstream e;
e << "Unable to successfully run MaskDetectors Child Algorithm: "
<< err.what();
g_log.error(e.str());
}
}
}
void TOFSANSResolutionByPixel::exec() {
MatrixWorkspace_sptr inWS = getProperty("InputWorkspace");
double deltaR = getProperty("DeltaR");
double R1 = getProperty("SourceApertureRadius");
double R2 = getProperty("SampleApertureRadius");
const bool doGravity = getProperty("AccountForGravity");
// Check the input
checkInput(inWS);
// Setup outputworkspace
auto outWS = setupOutputWorkspace(inWS);
// Convert to meters
deltaR /= 1000.0;
R1 /= 1000.0;
R2 /= 1000.0;
// The moderator workspace needs to match the data workspace
// in terms of wavelength binning
const MatrixWorkspace_sptr sigmaModeratorVSwavelength =
getModeratorWorkspace(inWS);
// create interpolation table from sigmaModeratorVSwavelength
Kernel::Interpolation lookUpTable;
const auto &xInterpolate = sigmaModeratorVSwavelength->points(0);
const auto &yInterpolate = sigmaModeratorVSwavelength->y(0);
// prefer the input to be a pointworkspace and create interpolation function
if (sigmaModeratorVSwavelength->isHistogramData()) {
g_log.notice() << "mid-points of SigmaModerator histogram bins will be "
"used for interpolation.";
}
for (size_t i = 0; i < xInterpolate.size(); ++i) {
lookUpTable.addPoint(xInterpolate[i], yInterpolate[i]);
}
// Calculate the L1 distance
const V3D samplePos = inWS->getInstrument()->getSample()->getPos();
const V3D sourcePos = inWS->getInstrument()->getSource()->getPos();
const V3D SSD = samplePos - sourcePos;
const double L1 = SSD.norm();
// Get the collimation length
double LCollim = getProperty("CollimationLength");
if (LCollim == 0.0) {
auto collimationLengthEstimator = SANSCollimationLengthEstimator();
LCollim = collimationLengthEstimator.provideCollimationLength(inWS);
g_log.information() << "No collimation length was specified. A default "
"collimation length was estimated to be " << LCollim
<< '\n';
} else {
g_log.information() << "The collimation length is " << LCollim << '\n';
}
const int numberOfSpectra = static_cast<int>(inWS->getNumberHistograms());
Progress progress(this, 0.0, 1.0, numberOfSpectra);
const auto &spectrumInfo = inWS->spectrumInfo();
for (int i = 0; i < numberOfSpectra; i++) {
IDetector_const_sptr det;
if (!spectrumInfo.hasDetectors(i)) {
g_log.information() << "Workspace index " << i
<< " has no detector assigned to it - discarding\n";
continue;
}
// If no detector found or if it's masked or a monitor, skip onto the next
// spectrum
if (spectrumInfo.isMonitor(i) || spectrumInfo.isMasked(i))
continue;
const double L2 = spectrumInfo.l2(i);
TOFSANSResolutionByPixelCalculator calculator;
const double waveLengthIndependentFactor =
calculator.getWavelengthIndependentFactor(R1, R2, deltaR, LCollim, L2);
// Multiplicative factor to go from lambda to Q
// Don't get fooled by the function name...
const double theta = spectrumInfo.twoTheta(i);
double sinTheta = sin(0.5 * theta);
double factor = 4.0 * M_PI * sinTheta;
const auto &xIn = inWS->x(i);
const size_t xLength = xIn.size();
// Gravity correction
std::unique_ptr<GravitySANSHelper> grav;
if (doGravity) {
grav = Kernel::make_unique<GravitySANSHelper>(spectrumInfo, i,
getProperty("ExtraLength"));
}
// Get handles on the outputWorkspace
auto &yOut = outWS->mutableY(i);
// for each wavelenght bin of each pixel calculate a q-resolution
for (size_t j = 0; j < xLength - 1; j++) {
// use the midpoint of each bin
const double wl = (xIn[j + 1] + xIn[j]) / 2.0;
// Calculate q. Alternatively q could be calculated using ConvertUnit
// If we include a gravity correction we need to adjust sinTheta
// for each wavelength (in Angstrom)
if (doGravity) {
double sinThetaGrav = grav->calcSinTheta(wl);
factor = 4.0 * M_PI * sinThetaGrav;
}
const double q = factor / wl;
// wavelenght spread from bin assumed to be
const double sigmaSpreadFromBin = xIn[j + 1] - xIn[j];
// Get the uncertainty in Q
auto sigmaQ = calculator.getSigmaQValue(lookUpTable.value(wl),
waveLengthIndependentFactor, q,
wl, sigmaSpreadFromBin, L1, L2);
// Insert the Q value and the Q resolution into the outputworkspace
yOut[j] = sigmaQ;
}
progress.report("Computing Q resolution");
}
// Set the y axis label
outWS->setYUnitLabel("QResolution");
setProperty("OutputWorkspace", outWS);
}
/** 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();
}
}
