size_t MaskPeaksWorkspace::getWkspIndex(const detid2index_map &pixel_to_wi,
Geometry::IComponent_const_sptr comp,
const int x, const int y) {
Geometry::RectangularDetector_const_sptr det =
boost::dynamic_pointer_cast<const Geometry::RectangularDetector>(comp);
if (det) {
if (x >= det->xpixels() || x < 0 || y >= det->ypixels() || y < 0)
return EMPTY_INT();
if ((x >= det->xpixels()) ||
(x < 0) // this check is unnecessary as callers are doing it too
|| (y >= det->ypixels()) ||
(y < 0)) // but just to make debugging easier
{
std::stringstream msg;
msg << "Failed to find workspace index for x=" << x << " y=" << y
<< "(max x=" << det->xpixels() << ", max y=" << det->ypixels() << ")";
throw std::runtime_error(msg.str());
}
int pixelID = det->getAtXY(x, y)->getID();
// Find the corresponding workspace index, if any
auto wiEntry = pixel_to_wi.find(pixelID);
if (wiEntry == pixel_to_wi.end()) {
std::stringstream msg;
msg << "Failed to find workspace index for x=" << x << " y=" << y;
throw std::runtime_error(msg.str());
}
return wiEntry->second;
} else {
std::vector<Geometry::IComponent_const_sptr> children;
boost::shared_ptr<const Geometry::ICompAssembly> asmb =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(comp);
asmb->getChildren(children, false);
boost::shared_ptr<const Geometry::ICompAssembly> asmb2 =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(children[0]);
std::vector<Geometry::IComponent_const_sptr> grandchildren;
asmb2->getChildren(grandchildren, false);
int NROWS = static_cast<int>(grandchildren.size());
int NCOLS = static_cast<int>(children.size());
// Wish pixels and tubes start at 1 not 0
if (x - 1 >= NCOLS || x - 1 < 0 || y - 1 >= NROWS || y - 1 < 0)
return EMPTY_INT();
std::string bankName = comp->getName();
detid2index_map::const_iterator it =
pixel_to_wi.find(findPixelID(bankName, x, y));
if (it == pixel_to_wi.end())
return EMPTY_INT();
return (it->second);
}
}
/* Set workspace->group ID map by detectors (range)
*
*/
void LoadDetectorsGroupingFile::setByDetectors() {
// 0. Check
if (!m_instrument && m_groupDetectorsMap.size() > 0) {
std::map<int, std::vector<detid_t>>::iterator mapiter;
bool norecord = true;
for (mapiter = m_groupDetectorsMap.begin();
mapiter != m_groupDetectorsMap.end(); ++mapiter)
if (mapiter->second.size() > 0) {
norecord = false;
g_log.error() << "Instrument is not specified in XML file. "
<< "But tag 'detid' is used in XML file for Group "
<< mapiter->first << ". It is not allowed. " << std::endl;
break;
}
if (!norecord)
throw std::invalid_argument(
"XML definition involving detectors causes error");
}
// 1. Prepare
const detid2index_map indexmap =
m_groupWS->getDetectorIDToWorkspaceIndexMap(true);
// 2. Set GroupingWorkspace
for (auto &detectorMap : m_groupDetectorsMap) {
g_log.debug() << "Group ID = " << detectorMap.first << std::endl;
for (auto detid : detectorMap.second) {
auto itx = indexmap.find(detid);
if (itx != indexmap.end()) {
size_t wsindex = itx->second;
m_groupWS->dataY(wsindex)[0] = detectorMap.first;
} else {
g_log.error() << "Pixel w/ ID = " << detid << " Cannot Be Located"
<< std::endl;
}
} // ENDFOR detid (in range)
} // ENDFOR each group ID
return;
}
/** Mask detectors or Unmask detectors
* @param indexmap: spectraId to spectraNum map used
* in masking
* @param tomask: true to mask, false to unmask
* @param singledetids: list of individual det ids to mask
*/
void LoadMask::processMaskOnDetectors(
const detid2index_map &indexmap, bool tomask,
const std::vector<detid_t> &singledetids) {
// 1. Get index map
// 2. Mask
g_log.debug() << "Mask = " << tomask
<< " Final Single IDs Size = " << singledetids.size() << '\n';
for (auto detid : singledetids) {
detid2index_map::const_iterator it;
it = indexmap.find(detid);
if (it != indexmap.end()) {
size_t index = it->second;
m_maskWS->mutableY(index)[0] = (tomask) ? 1 : 0;
} else {
g_log.warning() << "Pixel w/ ID = " << detid << " Cannot Be Located\n";
}
}
}
/** Calculate (all) detectors' offsets
*/
void GetDetOffsetsMultiPeaks::calculateDetectorsOffsets() {
int nspec = static_cast<int>(m_inputWS->getNumberHistograms());
// To get the workspace index from the detector ID
const detid2index_map pixel_to_wi =
m_maskWS->getDetectorIDToWorkspaceIndexMap(true);
// Fit all the spectra with a gaussian
Progress prog(this, 0, 1.0, nspec);
// cppcheck-suppress syntaxError
PRAGMA_OMP(parallel for schedule(dynamic, 1) )
for (int wi = 0; wi < nspec; ++wi) {
PARALLEL_START_INTERUPT_REGION
std::vector<double> fittedpeakpositions, tofitpeakpositions;
FitPeakOffsetResult offsetresult =
calculatePeakOffset(wi, fittedpeakpositions, tofitpeakpositions);
// Get the list of detectors in this pixel
const std::set<detid_t> &dets =
m_inputWS->getSpectrum(wi)->getDetectorIDs();
// Most of the exec time is in FitSpectra, so this critical block should
// not be a problem.
PARALLEL_CRITICAL(GetDetOffsetsMultiPeaks_setValue) {
// Use the same offset for all detectors from this pixel (in case of
// summing pixels)
std::set<detid_t>::iterator it;
for (it = dets.begin(); it != dets.end(); ++it) {
// Set value to output peak offset workspace
m_outputW->setValue(*it, offsetresult.offset, offsetresult.fitSum);
// Set value to output peak number workspace
m_outputNP->setValue(*it, offsetresult.peakPosFittedSize,
offsetresult.chisqSum);
// Set value to mask workspace
const auto mapEntry = pixel_to_wi.find(*it);
if (mapEntry == pixel_to_wi.end())
continue;
const size_t workspaceIndex = mapEntry->second;
if (offsetresult.mask > 0.9) {
// Being masked
m_maskWS->maskWorkspaceIndex(workspaceIndex);
m_maskWS->dataY(workspaceIndex)[0] = offsetresult.mask;
} else {
// Using the detector
m_maskWS->dataY(workspaceIndex)[0] = offsetresult.mask;
// check the average value of delta(d)/d. if it is far off the
// theorical value, output
// FIXME - This warning should not appear by filtering out peaks
// that are too wide or narrow.
// TODO - Delete the if statement below if it is never triggered.
if (m_hasInputResolution) {
double pixelresolution = m_inputResolutionWS->readY(wi)[0];
if (offsetresult.resolution > 10 * pixelresolution ||
offsetresult.resolution < 0.1 * pixelresolution)
g_log.warning() << "Spectrum " << wi
<< " delta(d)/d = " << offsetresult.resolution
<< "\n";
}
}
} // ENDFOR (detectors)
// Report offset fitting result/status
addInfoToReportWS(wi, offsetresult, tofitpeakpositions,
fittedpeakpositions);
} // End of critical region
prog.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
return;
}
/*
* Convert Componenet -> Detector IDs -> Workspace Indices -> set group ID
*/
void LoadDetectorsGroupingFile::setByComponents() {
// 0. Check
if (!m_instrument) {
std::map<int, std::vector<std::string>>::iterator mapiter;
bool norecord = true;
for (mapiter = m_groupComponentsMap.begin();
mapiter != m_groupComponentsMap.end(); ++mapiter) {
if (mapiter->second.size() > 0) {
g_log.error() << "Instrument is not specified in XML file. "
<< "But tag 'component' is used in XML file for Group "
<< mapiter->first << " It is not allowed" << std::endl;
norecord = false;
break;
}
}
if (!norecord)
throw std::invalid_argument(
"XML definition involving component causes error");
}
// 1. Prepare
const detid2index_map indexmap =
m_groupWS->getDetectorIDToWorkspaceIndexMap(true);
// 2. Set
for (auto &componentMap : m_groupComponentsMap) {
g_log.debug() << "Group ID = " << componentMap.first << " With "
<< componentMap.second.size() << " Components" << std::endl;
for (auto &name : componentMap.second) {
// a) get component
Geometry::IComponent_const_sptr component =
m_instrument->getComponentByName(name);
// b) component -> component assembly --> children (more than detectors)
boost::shared_ptr<const Geometry::ICompAssembly> asmb =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(component);
std::vector<Geometry::IComponent_const_sptr> children;
asmb->getChildren(children, true);
g_log.debug() << "Component Name = " << name
<< " Component ID = " << component->getComponentID()
<< "Number of Children = " << children.size() << std::endl;
for (auto child : children) {
// c) convert component to detector
Geometry::IDetector_const_sptr det =
boost::dynamic_pointer_cast<const Geometry::IDetector>(child);
if (det) {
// Component is DETECTOR:
int32_t detid = det->getID();
auto itx = indexmap.find(detid);
if (itx != indexmap.end()) {
size_t wsindex = itx->second;
m_groupWS->dataY(wsindex)[0] = componentMap.first;
} else {
g_log.error() << "Pixel w/ ID = " << detid << " Cannot Be Located"
<< std::endl;
}
} // ENDIF Detector
} // ENDFOR (children of component)
} // ENDFOR (component)
} // ENDFOR GroupID
return;
}
int PeakIntegration::fitneighbours(int ipeak, std::string det_name, int x0,
int y0, int idet, double qspan,
PeaksWorkspace_sptr &Peaks,
const detid2index_map &pixel_to_wi) {
UNUSED_ARG(ipeak);
UNUSED_ARG(det_name);
UNUSED_ARG(x0);
UNUSED_ARG(y0);
Geometry::IPeak &peak = Peaks->getPeak(ipeak);
// Number of slices
int TOFmax = 0;
IAlgorithm_sptr slice_alg = createChildAlgorithm("IntegratePeakTimeSlices");
slice_alg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", inputW);
std::ostringstream tab_str;
tab_str << "LogTable" << ipeak;
slice_alg->setPropertyValue("OutputWorkspace", tab_str.str());
slice_alg->setProperty<PeaksWorkspace_sptr>("Peaks", Peaks);
slice_alg->setProperty("PeakIndex", ipeak);
slice_alg->setProperty("PeakQspan", qspan);
int nPixels = std::max<int>(0, getProperty("NBadEdgePixels"));
slice_alg->setProperty("NBadEdgePixels", nPixels);
slice_alg->executeAsChildAlg();
Mantid::API::MemoryManager::Instance().releaseFreeMemory();
MantidVec &Xout = outputW->dataX(idet);
MantidVec &Yout = outputW->dataY(idet);
MantidVec &Eout = outputW->dataE(idet);
TableWorkspace_sptr logtable = slice_alg->getProperty("OutputWorkspace");
peak.setIntensity(slice_alg->getProperty("Intensity"));
peak.setSigmaIntensity(slice_alg->getProperty("SigmaIntensity"));
TOFmax = static_cast<int>(logtable->rowCount());
for (int iTOF = 0; iTOF < TOFmax; iTOF++) {
Xout[iTOF] = logtable->getRef<double>(std::string("Time"), iTOF);
if (m_IC) // Ikeda-Carpenter fit
{
Yout[iTOF] = logtable->getRef<double>(std::string("TotIntensity"), iTOF);
Eout[iTOF] =
logtable->getRef<double>(std::string("TotIntensityError"), iTOF);
} else {
Yout[iTOF] = logtable->getRef<double>(std::string("ISAWIntensity"), iTOF);
Eout[iTOF] =
logtable->getRef<double>(std::string("ISAWIntensityError"), iTOF);
}
}
outputW->getSpectrum(idet)->clearDetectorIDs();
// Find the pixel ID at that XY position on the rectangular detector
int pixelID = peak.getDetectorID(); // det->getAtXY(x0,y0)->getID();
// Find the corresponding workspace index, if any
auto wiEntry = pixel_to_wi.find(pixelID);
if (wiEntry != pixel_to_wi.end()) {
size_t wi = wiEntry->second;
// Set detectorIDs
outputW->getSpectrum(idet)
->addDetectorIDs(inputW->getSpectrum(wi)->getDetectorIDs());
}
return TOFmax - 1;
}