/** 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; } }