/** 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 the vtkStructuredGrid from the provided workspace
@param progressUpdating: Reporting object to pass progress information up the stack.
@return fully constructed vtkDataSet.
*/
vtkDataSet* vtkMDQuadFactory::create(ProgressAction& progressUpdating) const
{
vtkDataSet* product = tryDelegatingCreation<IMDEventWorkspace, 2>(m_workspace, progressUpdating);
if(product != NULL)
{
return product;
}
else
{
IMDEventWorkspace_sptr imdws = this->castAndCheck<IMDEventWorkspace, 2>(m_workspace);
// Acquire a scoped read-only lock to the workspace (prevent segfault from algos modifying ws)
Mantid::Kernel::ReadLock lock(*imdws);
const size_t nDims = imdws->getNumDims();
size_t nNonIntegrated = imdws->getNonIntegratedDimensions().size();
/*
Write mask array with correct order for each internal dimension.
*/
bool* masks = new bool[nDims];
for(size_t i_dim = 0; i_dim < nDims; ++i_dim)
{
bool bIntegrated = imdws->getDimension(i_dim)->getIsIntegrated();
masks[i_dim] = !bIntegrated; //TRUE for unmaksed, integrated dimensions are masked.
}
//Ensure destruction in any event.
boost::scoped_ptr<IMDIterator> it(imdws->createIterator());
// Create 4 points per box.
vtkPoints *points = vtkPoints::New();
points->SetNumberOfPoints(it->getDataSize() * 4);
// One scalar per box
vtkFloatArray * signals = vtkFloatArray::New();
signals->Allocate(it->getDataSize());
signals->SetName(m_scalarName.c_str());
signals->SetNumberOfComponents(1);
size_t nVertexes;
vtkUnstructuredGrid *visualDataSet = vtkUnstructuredGrid::New();
visualDataSet->Allocate(it->getDataSize());
vtkIdList * quadPointList = vtkIdList::New();
quadPointList->SetNumberOfIds(4);
Mantid::API::CoordTransform* transform = NULL;
if (m_useTransform)
{
transform = imdws->getTransformToOriginal();
}
Mantid::coord_t out[2];
bool* useBox = new bool[it->getDataSize()];
double progressFactor = 0.5/double(it->getDataSize());
double progressOffset = 0.5;
size_t iBox = 0;
do
{
progressUpdating.eventRaised(progressFactor * double(iBox));
Mantid::signal_t signal_normalized= it->getNormalizedSignal();
if (!isSpecial( signal_normalized ) && m_thresholdRange->inRange(signal_normalized))
{
useBox[iBox] = true;
signals->InsertNextValue(static_cast<float>(signal_normalized));
coord_t* coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
delete [] coords;
coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
//Iterate through all coordinates. Candidate for speed improvement.
for(size_t v = 0; v < nVertexes; ++v)
{
coord_t * coord = coords + v*2;
size_t id = iBox*4 + v;
if(m_useTransform)
{
transform->apply(coord, out);
points->SetPoint(id, out[0], out[1], 0);
}
else
{
points->SetPoint(id, coord[0], coord[1], 0);
}
}
// Free memory
delete [] coords;
} // valid number of vertexes returned
else
{
useBox[iBox] = false;
}
++iBox;
} while (it->next());
delete[] masks;
for(size_t ii = 0; ii < it->getDataSize() ; ++ii)
{
progressUpdating.eventRaised((progressFactor * double(ii)) + progressOffset);
if (useBox[ii] == true)
{
vtkIdType pointIds = vtkIdType(ii * 4);
quadPointList->SetId(0, pointIds + 0); //xyx
quadPointList->SetId(1, pointIds + 1); //dxyz
quadPointList->SetId(2, pointIds + 3); //dxdyz
quadPointList->SetId(3, pointIds + 2); //xdyz
visualDataSet->InsertNextCell(VTK_QUAD, quadPointList);
} // valid number of vertexes returned
}
delete[] useBox;
signals->Squeeze();
points->Squeeze();
visualDataSet->SetPoints(points);
visualDataSet->GetCellData()->SetScalars(signals);
visualDataSet->Squeeze();
signals->Delete();
points->Delete();
quadPointList->Delete();
return visualDataSet;
}
}
