/** Export events from an MDEventWorkspace for future processing
* It is a convenient algorithm if number of events are few relative to
* number of detectors
*/
void ConvertCWSDMDtoHKL::exportEvents(
IMDEventWorkspace_sptr mdws, std::vector<Kernel::V3D> &vec_event_qsample,
std::vector<signal_t> &vec_event_signal,
std::vector<detid_t> &vec_event_det) {
// Set the size of the output vectors
size_t numevents = mdws->getNEvents();
g_log.information() << "Number of events = " << numevents << "\n";
vec_event_qsample.resize(numevents);
vec_event_signal.resize(numevents);
vec_event_det.resize(numevents);
// Go through to get value
IMDIterator *mditer = mdws->createIterator();
size_t nextindex = 1;
bool scancell = true;
size_t currindex = 0;
while (scancell) {
size_t numevent_cell = mditer->getNumEvents();
for (size_t iev = 0; iev < numevent_cell; ++iev) {
// Check
if (currindex >= vec_event_qsample.size())
throw std::runtime_error("Logic error in event size!");
float tempx = mditer->getInnerPosition(iev, 0);
float tempy = mditer->getInnerPosition(iev, 1);
float tempz = mditer->getInnerPosition(iev, 2);
signal_t signal = mditer->getInnerSignal(iev);
detid_t detid = mditer->getInnerDetectorID(iev);
Kernel::V3D qsample(tempx, tempy, tempz);
vec_event_qsample[currindex] = qsample;
vec_event_signal[currindex] = signal;
vec_event_det[currindex] = detid;
++currindex;
}
// Advance to next cell
if (mditer->next()) {
// advance to next cell
mditer->jumpTo(nextindex);
++nextindex;
} else {
// break the loop
scancell = false;
}
}
return;
}
/**
Create iterators with correct normalization normalization to an IMDIterator.
@param normalizationOption : Visual Normalization option desired
@param ws : workspace to fetch defaults from if needed
@return new IMDIterator
*/
DLLExport Mantid::API::IMDIterator *
createIteratorWithNormalization(const VisualNormalization normalizationOption,
Mantid::API::IMDWorkspace const *const ws) {
using namespace Mantid::API;
MDNormalization targetNormalization;
// Fetch the default and continue
if (normalizationOption == AutoSelect) {
// enum to enum.
targetNormalization =
static_cast<MDNormalization>(ws->displayNormalization());
}
else {
targetNormalization = static_cast<MDNormalization>(normalizationOption);
}
// Create the iterator
IMDIterator * iterator = ws->createIterator();
// Set normalization
iterator->setNormalization(targetNormalization);
// Return it
return iterator;
}
//----------------------------------------------------------------------------------------------
/// Run the algorithm
void QueryMDWorkspace::exec() {
// Extract the required normalisation.
std::string strNormalisation = getPropertyValue("Normalisation");
MDNormalization requestedNormalisation = whichNormalisation(strNormalisation);
IMDWorkspace_sptr input = getProperty("InputWorkspace");
const bool transformCoordsToOriginal = getProperty("TransformCoordsToOriginal");
// Define a table workspace with a specific column schema.
ITableWorkspace_sptr output = WorkspaceFactory::Instance().createTable();
const std::string signalColumnName = "Signal/" + strNormalisation;
const std::string errorColumnName = "Error/" + strNormalisation;
output->addColumn("double", signalColumnName);
output->addColumn("double", errorColumnName);
output->addColumn("int", "Number of Events");
const size_t ndims = input->getNumDims();
for (size_t index = 0; index < ndims; ++index) {
Mantid::Geometry::IMDDimension_const_sptr dim = input->getDimension(index);
std::string dimInUnit = dim->getName() + "/" + dim->getUnits().ascii();
output->addColumn("double", dimInUnit);
// Magic numbers required to configure the X axis.
output->getColumn(dimInUnit)->setPlotType(1);
}
// Magic numbers required to configure the Y axis.
output->getColumn(signalColumnName)->setPlotType(2);
output->getColumn(errorColumnName)->setPlotType(5);
IMDIterator *it = input->createIterator();
it->setNormalization(requestedNormalisation);
bool bLimitRows = getProperty("LimitRows");
int maxRows = 0;
if (bLimitRows) {
maxRows = getProperty("MaximumRows");
}
// Use the iterator to loop through each MDBoxBase and create a row for each
// entry.
int rowCounter = 0;
Progress progress(this, 0, 1, int64_t(input->getNPoints()));
while (true) {
size_t cellIndex = 0;
output->appendRow();
output->cell<double>(rowCounter, cellIndex++) = it->getNormalizedSignal();
output->cell<double>(rowCounter, cellIndex++) = it->getNormalizedError();
output->cell<int>(rowCounter, cellIndex++) = int(it->getNumEvents());
VMD center = it->getCenter();
const size_t numberOriginal = input->getNumberTransformsToOriginal();
if (transformCoordsToOriginal && numberOriginal > 0) {
const size_t index = numberOriginal - 1;
CoordTransform const *transform = input->getTransformToOriginal(index);
VMD temp = transform->applyVMD(center);
center = temp;
}
for (size_t index = 0; index < ndims; ++index) {
output->cell<double>(rowCounter, cellIndex++) = center[index];
}
progress.report();
if (!it->next() || (bLimitRows && ((rowCounter + 1) >= maxRows))) {
break;
}
rowCounter++;
}
setProperty("OutputWorkspace", output);
delete it;
//
IMDEventWorkspace_sptr mdew;
CALL_MDEVENT_FUNCTION(this->getBoxData, input);
}
/** Get detectors' counts
* @brief GetSpiceDataRawCountsFromMD::getDetCounts
* @param mdws
* @param runnumber :: run number of the detectors having for exporting; -1 for
* all run numbers
* @param detid :: detector ID for the detectors for exporting; -1 for all
* detectors
* @param vecX :: x-values as 2theta position of detectors to be exported;
* @param vecY :: raw detector's counts
* @param formX :: flag to set up vecX
*/
void GetSpiceDataRawCountsFromMD::getDetCounts(
API::IMDEventWorkspace_const_sptr mdws, const int &runnumber,
const int &detid, std::vector<double> &vecX, std::vector<double> &vecY,
bool formX) {
// Get sample and source position
if (mdws->getNumExperimentInfo() == 0)
throw std::runtime_error(
"There is no ExperimentInfo object that has been set to "
"input MDEventWorkspace!");
V3D samplepos;
V3D sourcepos;
if (formX) {
ExperimentInfo_const_sptr expinfo = mdws->getExperimentInfo(0);
Geometry::IComponent_const_sptr sample =
expinfo->getInstrument()->getSample();
samplepos = sample->getPos();
g_log.debug() << "Sample position is " << samplepos.X() << ", "
<< samplepos.Y() << ", " << samplepos.Z() << "\n";
Geometry::IComponent_const_sptr source =
expinfo->getInstrument()->getSource();
sourcepos = source->getPos();
g_log.debug() << "Source position is " << sourcepos.X() << ","
<< sourcepos.Y() << ", " << sourcepos.Z() << "\n";
vecX.clear();
}
vecY.clear();
// Go through all events to find out their positions
IMDIterator *mditer = mdws->createIterator();
bool scancell = true;
size_t nextindex = 1;
while (scancell) {
// get the number of events of this cell
size_t numev2 = mditer->getNumEvents();
g_log.debug() << "MDWorkspace " << mdws->name() << " Cell " << nextindex - 1
<< ": Number of events = " << numev2
<< " Does NEXT cell exist = " << mditer->next() << "\n";
// loop over all the events in current cell
for (size_t iev = 0; iev < numev2; ++iev) {
// filter out the events with uninterrested run numbers and detid
// runnumber/detid < 0 indicates that all run number or all detectors will
// be taken
int thisrunnumber = mditer->getInnerRunIndex(iev);
if (runnumber >= 0 && thisrunnumber != runnumber)
continue;
int thisdetid = mditer->getInnerDetectorID(iev);
if (detid >= 0 && thisdetid != detid)
continue;
// get detector position for 2theta
if (formX) {
double tempx = mditer->getInnerPosition(iev, 0);
double tempy = mditer->getInnerPosition(iev, 1);
double tempz = mditer->getInnerPosition(iev, 2);
Kernel::V3D detpos(tempx, tempy, tempz);
Kernel::V3D v_det_sample = detpos - samplepos;
Kernel::V3D v_sample_src = samplepos - sourcepos;
double twotheta = v_det_sample.angle(v_sample_src) / M_PI * 180.;
vecX.push_back(twotheta);
}
// add new value to vecPair
double signal = mditer->getInnerSignal(iev);
vecY.push_back(signal);
} // ENDFOR (iev)
// Advance to next cell
if (mditer->next()) {
// advance to next cell
mditer->jumpTo(nextindex);
++nextindex;
} else {
// break the loop
scancell = false;
}
} // ENDOF(while)
delete (mditer);
return;
}
