/** 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
*/
API::MatrixWorkspace_sptr SofQWCentre::setUpOutputWorkspace(
API::MatrixWorkspace_const_sptr inputWorkspace,
const std::vector<double> &binParams, std::vector<double> &newAxis) {
// Create vector to hold the new X axis values
HistogramData::BinEdges xAxis(inputWorkspace->sharedX(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 outputWorkspace = WorkspaceFactory::Instance().create(
inputWorkspace, yLength - 1, xLength, xLength - 1);
// Create a numeric axis to replace the default vertical one
Axis *const verticalAxis = new BinEdgeAxis(newAxis);
outputWorkspace->replaceAxis(1, verticalAxis);
// Now set the axis values
for (int i = 0; i < yLength - 1; ++i) {
outputWorkspace->setBinEdges(i, xAxis);
}
// 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";
outputWorkspace->setYUnit("");
outputWorkspace->setYUnitLabel("Intensity");
return outputWorkspace;
}
/**
* Construct an "empty" output workspace in virtual-lambda for summation in Q.
* The workspace will have the same x values as the input workspace but the y
* values will all be zero.
*
* @return : a 1D workspace where y values are all zero
*/
MatrixWorkspace_sptr
ReflectometryReductionOne2::constructIvsLamWS(MatrixWorkspace_sptr detectorWS) {
// There is one output spectrum for each detector group
const size_t numGroups = detectorGroups().size();
// Calculate the number of bins based on the min/max wavelength, using
// the same bin width as the input workspace
const double binWidth = (detectorWS->x(0).back() - detectorWS->x(0).front()) /
static_cast<double>(detectorWS->blocksize());
const int numBins = static_cast<int>(
std::ceil((wavelengthMax() - wavelengthMin()) / binWidth));
// Construct the histogram with these X values. Y and E values are zero.
const BinEdges xValues(numBins, LinearGenerator(wavelengthMin(), binWidth));
// Create the output workspace
MatrixWorkspace_sptr outputWS = WorkspaceFactory::Instance().create(
detectorWS, numGroups, numBins, numBins - 1);
// Loop through each detector group in the input
for (size_t groupIdx = 0; groupIdx < numGroups; ++groupIdx) {
// Get the detectors in this group
auto &detectors = detectorGroups()[groupIdx];
// Set the x values for this spectrum
outputWS->setBinEdges(groupIdx, xValues);
// Set the detector ID from the twoThetaR detector.
const size_t twoThetaRIdx = twoThetaRDetectorIdx(detectors);
auto &outSpec = outputWS->getSpectrum(groupIdx);
const detid_t twoThetaRDetID =
m_spectrumInfo->detector(twoThetaRIdx).getID();
outSpec.clearDetectorIDs();
outSpec.addDetectorID(twoThetaRDetID);
// Set the spectrum number from the twoThetaR detector
SpectrumNumber specNum =
detectorWS->indexInfo().spectrumNumber(twoThetaRIdx);
auto indexInf = outputWS->indexInfo();
indexInf.setSpectrumNumbers(specNum, specNum);
outputWS->setIndexInfo(indexInf);
}
return outputWS;
}
/** Creates the output workspace, its size, units, etc.
* @param binParams the bin boundary specification using the same same syntax as
* param the Rebin algorithm
* @return A pointer to the newly-created workspace
*/
API::MatrixWorkspace_sptr
Q1D2::setUpOutputWorkspace(const std::vector<double> &binParams) const {
// Calculate the output binning
HistogramData::BinEdges XOut(0);
size_t sizeOut = static_cast<size_t>(VectorHelper::createAxisFromRebinParams(
binParams, XOut.mutableRawData()));
// Now create the output workspace
MatrixWorkspace_sptr outputWS =
WorkspaceFactory::Instance().create(m_dataWS, 1, sizeOut, sizeOut - 1);
outputWS->getAxis(0)->unit() =
UnitFactory::Instance().create("MomentumTransfer");
outputWS->setYUnitLabel("1/cm");
// Set the X vector for the output workspace
outputWS->setBinEdges(0, XOut);
outputWS->setDistribution(true);
outputWS->getSpectrum(0).clearDetectorIDs();
outputWS->getSpectrum(0).setSpectrumNo(1);
return outputWS;
}
/** Create a Workspace2D (MatrixWorkspace) with given spectra and bin parameters
*/
MatrixWorkspace_sptr
GeneratePeaks::createDataWorkspace(std::vector<double> binparameters) {
// Check validity
if (m_spectraSet.empty())
throw std::invalid_argument(
"Input spectra list is empty. Unable to generate a new workspace.");
if (binparameters.size() < 3) {
std::stringstream errss;
errss << "Number of input binning parameters are not enough ("
<< binparameters.size() << "). "
<< "Binning parameters should be 3 (x0, step, xf).";
g_log.error(errss.str());
throw std::invalid_argument(errss.str());
}
double x0 = binparameters[0];
double dx = binparameters[1]; // binDelta
double xf = binparameters[2]; // max value
if (x0 >= xf || (xf - x0) < dx || dx == 0.) {
std::stringstream errss;
errss << "Order of input binning parameters is not correct. It is not "
"logical to have "
<< "x0 = " << x0 << ", xf = " << xf << ", dx = " << dx;
g_log.error(errss.str());
throw std::invalid_argument(errss.str());
}
std::vector<double> xarray;
double xvalue = x0;
while (xvalue <= xf) {
// Push current value to vector
xarray.push_back(xvalue);
// Calculate next value, linear or logarithmic
if (dx > 0)
xvalue += dx;
else
xvalue += fabs(dx) * xvalue;
}
size_t numxvalue = xarray.size();
BinEdges xArrayEdges(xarray);
// Create new workspace
MatrixWorkspace_sptr ws = API::WorkspaceFactory::Instance().create(
"Workspace2D", m_spectraSet.size(), numxvalue, numxvalue - 1);
for (size_t ip = 0; ip < m_spectraSet.size(); ip++) {
ws->setBinEdges(ip, xArrayEdges);
}
// Set spectrum numbers
std::map<specnum_t, specnum_t>::iterator spiter;
for (spiter = m_SpectrumMap.begin(); spiter != m_SpectrumMap.end();
++spiter) {
specnum_t specid = spiter->first;
specnum_t wsindex = spiter->second;
g_log.debug() << "Build WorkspaceIndex-Spectrum " << wsindex << " , "
<< specid << "\n";
ws->getSpectrum(wsindex).setSpectrumNo(specid);
}
return ws;
}
/** Execute the algorithm.
*/
void ResampleX::exec() {
// generically having access to the input workspace is a good idea
MatrixWorkspace_sptr inputWS = getProperty("InputWorkspace");
MatrixWorkspace_sptr outputWS = getProperty("OutputWorkspace");
bool inPlace = (inputWS == outputWS); // Rebinning in-place
m_isDistribution = inputWS->isDistribution();
m_isHistogram = inputWS->isHistogramData();
const int numSpectra = static_cast<int>(inputWS->getNumberHistograms());
// the easy parameters
m_useLogBinning = getProperty("LogBinning");
m_numBins = getProperty("NumberBins");
m_preserveEvents = getProperty("PreserveEvents");
// determine the xmin/xmax for the workspace
vector<double> xmins = getProperty("XMin");
vector<double> xmaxs = getProperty("XMax");
string error = determineXMinMax(inputWS, xmins, xmaxs);
if (!error.empty())
throw std::runtime_error(error);
bool common_limits = true;
{
double xmin_common = xmins[0];
double xmax_common = xmaxs[0];
for (size_t i = 1; i < xmins.size(); ++i) {
if (xmins[i] != xmin_common) {
common_limits = false;
break;
}
if (xmaxs[i] != xmax_common) {
common_limits = false;
break;
}
}
}
if (common_limits) {
g_log.debug() << "Common limits between all spectra\n";
} else {
g_log.debug() << "Does not have common limits between all spectra\n";
}
// start doing actual work
EventWorkspace_const_sptr inputEventWS =
boost::dynamic_pointer_cast<const EventWorkspace>(inputWS);
if (inputEventWS != nullptr) {
if (m_preserveEvents) {
if (inPlace) {
g_log.debug() << "Rebinning event workspace in place\n";
} else {
g_log.debug() << "Rebinning event workspace out of place\n";
outputWS = inputWS->clone();
}
auto outputEventWS =
boost::dynamic_pointer_cast<EventWorkspace>(outputWS);
if (common_limits) {
// get the delta from the first since they are all the same
BinEdges xValues(0);
const double delta = this->determineBinning(xValues.mutableRawData(),
xmins[0], xmaxs[0]);
g_log.debug() << "delta = " << delta << "\n";
outputEventWS->setAllX(xValues);
} else {
// initialize progress reporting.
Progress prog(this, 0.0, 1.0, numSpectra);
// do the rebinning
PARALLEL_FOR_IF(Kernel::threadSafe(*inputEventWS, *outputWS))
for (int wkspIndex = 0; wkspIndex < numSpectra; ++wkspIndex) {
PARALLEL_START_INTERUPT_REGION
BinEdges xValues(0);
const double delta = this->determineBinning(
xValues.mutableRawData(), xmins[wkspIndex], xmaxs[wkspIndex]);
g_log.debug() << "delta[wkspindex=" << wkspIndex << "] = " << delta
<< " xmin=" << xmins[wkspIndex]
<< " xmax=" << xmaxs[wkspIndex] << "\n";
outputEventWS->setHistogram(wkspIndex, xValues);
prog.report(name()); // Report progress
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
}
} // end if (m_preserveEvents)
else // event workspace -> matrix workspace
{
//--------- Different output, OR you're inplace but not preserving Events
g_log.information() << "Creating a Workspace2D from the EventWorkspace "
<< inputEventWS->getName() << ".\n";
outputWS = create<DataObjects::Workspace2D>(
*inputWS, numSpectra, HistogramData::BinEdges(m_numBins + 1));
// Initialize progress reporting.
Progress prog(this, 0.0, 1.0, numSpectra);
// Go through all the histograms and set the data
PARALLEL_FOR_IF(Kernel::threadSafe(*inputEventWS, *outputWS))
for (int wkspIndex = 0; wkspIndex < numSpectra; ++wkspIndex) {
PARALLEL_START_INTERUPT_REGION
// Set the X axis for each output histogram
MantidVec xValues;
const double delta =
this->determineBinning(xValues, xmins[wkspIndex], xmaxs[wkspIndex]);
g_log.debug() << "delta[wkspindex=" << wkspIndex << "] = " << delta
<< "\n";
outputWS->setBinEdges(wkspIndex, xValues);
// Get a const event list reference. inputEventWS->dataY() doesn't work.
const EventList &el = inputEventWS->getSpectrum(wkspIndex);
MantidVec y_data, e_data;
// The EventList takes care of histogramming.
el.generateHistogram(xValues, y_data, e_data);
// Copy the data over.
outputWS->mutableY(wkspIndex) = std::move(y_data);
outputWS->mutableE(wkspIndex) = std::move(e_data);
// Report progress
prog.report(name());
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
// Copy all the axes
for (int i = 1; i < inputWS->axes(); i++) {
outputWS->replaceAxis(i, inputWS->getAxis(i)->clone(outputWS.get()));
outputWS->getAxis(i)->unit() = inputWS->getAxis(i)->unit();
}
// Copy the units over too.
for (int i = 0; i < outputWS->axes(); ++i) {
outputWS->getAxis(i)->unit() = inputWS->getAxis(i)->unit();
}
outputWS->setYUnit(inputEventWS->YUnit());
outputWS->setYUnitLabel(inputEventWS->YUnitLabel());
}
// Assign it to the output workspace property
setProperty("OutputWorkspace", outputWS);
return;
} else // (inputeventWS != NULL)
