/**
* Convert to the output dimensions
* @param inputWs : Input Matrix workspace
* @return workspace group containing output matrix workspaces of ki and kf
*/
Mantid::API::MatrixWorkspace_sptr ReflectometryTransform::execute(
Mantid::API::MatrixWorkspace_const_sptr inputWs) const {
auto ws = boost::make_shared<Mantid::DataObjects::Workspace2D>();
ws->initialize(m_d1NumBins, m_d0NumBins,
m_d0NumBins); // Create the output workspace as a distribution
// Mapping so that d0 and d1 values calculated can be added to the matrix
// workspace at the correct index.
const double gradD0 =
double(m_d0NumBins) / (m_d0Max - m_d0Min); // The x - axis
const double gradD1 =
double(m_d1NumBins) / (m_d1Max - m_d1Min); // Actually the y-axis
const double cxToIndex = -gradD0 * m_d0Min;
const double cyToIndex = -gradD1 * m_d1Min;
const double cxToD0 = m_d0Min - (1 / gradD0);
const double cyToD1 = m_d1Min - (1 / gradD1);
// Create an X - Axis.
MantidVec xAxisVec = createXAxis(ws.get(), gradD0, cxToD0, m_d0NumBins,
m_d0Label, "1/Angstroms");
// Create a Y (vertical) Axis
createVerticalAxis(ws.get(), xAxisVec, gradD1, cyToD1, m_d1NumBins, m_d1Label,
"1/Angstroms");
// Loop over all entries in the input workspace and calculate d0 and d1
// for each.
auto spectraAxis = inputWs->getAxis(1);
for (size_t index = 0; index < inputWs->getNumberHistograms(); ++index) {
auto counts = inputWs->readY(index);
auto wavelengths = inputWs->readX(index);
auto errors = inputWs->readE(index);
const size_t nInputBins = wavelengths.size() - 1;
const double theta_final = spectraAxis->getValue(index);
m_calculator->setThetaFinal(theta_final);
// Loop over all bins in spectra
for (size_t binIndex = 0; binIndex < nInputBins; ++binIndex) {
const double wavelength =
0.5 * (wavelengths[binIndex] + wavelengths[binIndex + 1]);
double _d0 = m_calculator->calculateDim0(wavelength);
double _d1 = m_calculator->calculateDim1(wavelength);
if (_d0 >= m_d0Min && _d0 <= m_d0Max && _d1 >= m_d1Min &&
_d1 <= m_d1Max) // Check that the calculated ki and kf are in range
{
const int outIndexX = static_cast<int>((gradD0 * _d0) + cxToIndex);
const int outIndexZ = static_cast<int>((gradD1 * _d1) + cyToIndex);
ws->dataY(outIndexZ)[outIndexX] += counts[binIndex];
ws->dataE(outIndexZ)[outIndexX] += errors[binIndex];
}
}
}
return ws;
}
/**
* Performs centre-point rebinning and produces an MDWorkspace
* @param inputWs : The workspace you wish to perform centre-point rebinning on.
* @param boxController : controls how the MDWorkspace will be split
* @param frame: the md frame for the two MDHistoDimensions
* @returns An MDWorkspace based on centre-point rebinning of the inputWS
*/
Mantid::API::IMDEventWorkspace_sptr ReflectometryTransform::executeMD(
Mantid::API::MatrixWorkspace_const_sptr inputWs,
BoxController_sptr boxController,
Mantid::Geometry::MDFrame_uptr frame) const {
auto dim0 = boost::make_shared<MDHistoDimension>(
m_d0Label, m_d0ID, *frame, static_cast<Mantid::coord_t>(m_d0Min),
static_cast<Mantid::coord_t>(m_d0Max), m_d0NumBins);
auto dim1 = boost::make_shared<MDHistoDimension>(
m_d1Label, m_d1ID, *frame, static_cast<Mantid::coord_t>(m_d1Min),
static_cast<Mantid::coord_t>(m_d1Max), m_d1NumBins);
auto ws = createMDWorkspace(dim0, dim1, boxController);
auto spectraAxis = inputWs->getAxis(1);
for (size_t index = 0; index < inputWs->getNumberHistograms(); ++index) {
auto counts = inputWs->readY(index);
auto wavelengths = inputWs->readX(index);
auto errors = inputWs->readE(index);
const size_t nInputBins = wavelengths.size() - 1;
const double theta_final = spectraAxis->getValue(index);
m_calculator->setThetaFinal(theta_final);
// Loop over all bins in spectra
for (size_t binIndex = 0; binIndex < nInputBins; ++binIndex) {
const double &wavelength =
0.5 * (wavelengths[binIndex] + wavelengths[binIndex + 1]);
double _d0 = m_calculator->calculateDim0(wavelength);
double _d1 = m_calculator->calculateDim1(wavelength);
double centers[2] = {_d0, _d1};
ws->addEvent(MDLeanEvent<2>(float(counts[binIndex]),
float(errors[binIndex] * errors[binIndex]),
centers));
}
}
ws->splitAllIfNeeded(nullptr);
ws->refreshCache();
return ws;
}
/**
* Sum counts in detectors for purposes of rough plotting against the units on the x-axis.
* Assumes that all spectra have different x vectors.
*
* @param dets :: A list of detector IDs to sum.
* @param x :: (output) Time of flight values (or whatever values the x axis has) to plot against.
* @param y :: (output) The sums of the counts for each bin.
* @param size :: (input) Size of the output vectors.
*/
void InstrumentActor::sumDetectorsRagged(QList<int> &dets, std::vector<double> &x, std::vector<double> &y, size_t size) const
{
if ( dets.isEmpty() || size == 0 )
{
x.clear();
y.clear();
return;
}
Mantid::API::MatrixWorkspace_const_sptr ws = getWorkspace();
// create a workspace to hold the data from the selected detectors
Mantid::API::MatrixWorkspace_sptr dws = Mantid::API::WorkspaceFactory::Instance().create(ws,dets.size());
// x-axis limits
double xStart = maxBinValue();
double xEnd = minBinValue();
size_t nSpec = 0; // number of actual spectra to add
// fill in the temp workspace with the data from the detectors
foreach(int id, dets)
{
try {
size_t index = getWorkspaceIndex( id );
dws->dataX(nSpec) = ws->readX(index);
dws->dataY(nSpec) = ws->readY(index);
dws->dataE(nSpec) = ws->readE(index);
double xmin = dws->readX(nSpec).front();
double xmax = dws->readX(nSpec).back();
if ( xmin < xStart )
{
xStart = xmin;
}
if ( xmax > xEnd )
{
xEnd = xmax;
}
++nSpec;
} catch (Mantid::Kernel::Exception::NotFoundError &) {
continue; // Detector doesn't have a workspace index relating to it
}
}
if ( nSpec == 0 )
{
x.clear();
y.clear();
return;
}
// limits should exceed the integration range
if ( xStart < minBinValue() )
{
xStart = minBinValue();
}
if ( xEnd > maxBinValue() )
{
xEnd = maxBinValue();
}
double dx = (xEnd - xStart) / static_cast<double>(size - 1);
std::string params = QString("%1,%2,%3").arg(xStart).arg(dx).arg(xEnd).toStdString();
std::string outName = "_TMP_sumDetectorsRagged";
try
{
// rebin all spectra to the same binning
Mantid::API::IAlgorithm * alg = Mantid::API::FrameworkManager::Instance().createAlgorithm("Rebin",-1);
alg->setProperty( "InputWorkspace", dws );
alg->setPropertyValue( "OutputWorkspace", outName );
alg->setPropertyValue( "Params", params );
alg->execute();
ws = boost::dynamic_pointer_cast<Mantid::API::MatrixWorkspace>(Mantid::API::AnalysisDataService::Instance().retrieve(outName));
Mantid::API::AnalysisDataService::Instance().remove( outName );
x = ws->readX(0);
y = ws->readY(0);
// add the spectra
for(size_t i = 0; i < nSpec; ++i)
{
const Mantid::MantidVec& Y = ws->readY(i);
std::transform( y.begin(), y.end(), Y.begin(), y.begin(), std::plus<double>() );
}
}
catch(std::invalid_argument&)
{
// wrong Params for any reason
x.resize(size,(xEnd + xStart)/2);
y.resize(size,0.0);
}
}