/**
* Apply the created mapping to the workspace
*/
void CreateSimulationWorkspace::applyDetectorMapping() {
size_t wsIndex(0);
for (auto iter = m_detGroups.begin(); iter != m_detGroups.end(); ++iter) {
ISpectrum *spectrum = m_outputWS->getSpectrum(wsIndex);
spectrum->setSpectrumNo(
static_cast<specid_t>(wsIndex + 1)); // Ensure a contiguous mapping
spectrum->clearDetectorIDs();
spectrum->addDetectorIDs(iter->second);
++wsIndex;
}
}
/**
* Only to be used if the KeepUnGrouped property is true, moves the spectra that were not selected
* to be in a group to the end of the output spectrum
* @param unGroupedSet :: list of WORKSPACE indexes that were included in a group
* @param inputWS :: user selected input workspace for the algorithm
* @param outputWS :: user selected output workspace for the algorithm
* @param outIndex :: the next spectra index available after the grouped spectra
*/
void GroupDetectors2::moveOthers(const std::set<int64_t> &unGroupedSet, API::MatrixWorkspace_const_sptr inputWS, API::MatrixWorkspace_sptr outputWS,
size_t outIndex)
{
g_log.debug() << "Starting to copy the ungrouped spectra" << std::endl;
double prog4Copy = (1. - 1.*static_cast<double>(m_FracCompl))/static_cast<double>(unGroupedSet.size());
std::set<int64_t>::const_iterator copyFrIt = unGroupedSet.begin();
// go thorugh all the spectra in the input workspace
for ( ; copyFrIt != unGroupedSet.end(); ++copyFrIt )
{
if( *copyFrIt == USED ) continue; //Marked as not to be used
size_t sourceIndex = static_cast<size_t>(*copyFrIt);
// The input spectrum we'll copy
const ISpectrum * inputSpec = inputWS->getSpectrum(sourceIndex);
// Destination of the copying
ISpectrum * outputSpec = outputWS->getSpectrum(outIndex);
// Copy the data
outputSpec->dataX() = inputSpec->dataX();
outputSpec->dataY() = inputSpec->dataY();
outputSpec->dataE() = inputSpec->dataE();
// Spectrum numbers etc.
outputSpec->setSpectrumNo(inputSpec->getSpectrumNo());
outputSpec->clearDetectorIDs();
outputSpec->addDetectorIDs( inputSpec->getDetectorIDs() );
// go to the next free index in the output workspace
outIndex ++;
// make regular progress reports and check for cancelling the algorithm
if ( outIndex % INTERVAL == 0 )
{
m_FracCompl += INTERVAL*prog4Copy;
if ( m_FracCompl > 1.0 )
{
m_FracCompl = 1.0;
}
progress(m_FracCompl);
interruption_point();
}
}
// Refresh the spectraDetectorMap
outputWS->generateSpectraMap();
g_log.debug() << name() << " copied " << unGroupedSet.size()-1 << " ungrouped spectra\n";
}
void GatherWorkspaces::execEvent() {
// Every process in an MPI job must hit this next line or everything hangs!
mpi::communicator included; // The communicator containing all processes
// The root process needs to create a workspace of the appropriate size
EventWorkspace_sptr outputWorkspace;
if (included.rank() == 0) {
g_log.debug() << "Total number of spectra is " << totalSpec << "\n";
// Create the workspace for the output
outputWorkspace = boost::dynamic_pointer_cast<EventWorkspace>(
API::WorkspaceFactory::Instance().create("EventWorkspace", sumSpec,
numBins + hist, numBins));
// Copy geometry over.
API::WorkspaceFactory::Instance().initializeFromParent(
eventW, outputWorkspace, true);
setProperty("OutputWorkspace", outputWorkspace);
ExperimentInfo_sptr inWS = inputWorkspace;
outputWorkspace->copyExperimentInfoFrom(inWS.get());
}
for (size_t wi = 0; wi < totalSpec; wi++) {
if (included.rank() == 0) {
// How do we accumulate the data?
std::string accum = this->getPropertyValue("AccumulationMethod");
std::vector<Mantid::DataObjects::EventList> out_values;
gather(included, eventW->getEventList(wi), out_values, 0);
for (int i = 0; i < included.size(); i++) {
size_t index = wi; // accum == "Add"
if (accum == "Append")
index = wi + i * totalSpec;
outputWorkspace->dataX(index) = eventW->readX(wi);
outputWorkspace->getOrAddEventList(index) += out_values[i];
const ISpectrum *inSpec = eventW->getSpectrum(wi);
ISpectrum *outSpec = outputWorkspace->getSpectrum(index);
outSpec->clearDetectorIDs();
outSpec->addDetectorIDs(inSpec->getDetectorIDs());
}
} else {
gather(included, eventW->getEventList(wi), 0);
}
}
}
/**
* Move the user selected spectra in the input workspace into groups in the output workspace
* @param inputWS :: user selected input workspace for the algorithm
* @param outputWS :: user selected output workspace for the algorithm
* @param prog4Copy :: the amount of algorithm progress to attribute to moving a single spectra
* @return number of new grouped spectra
*/
size_t GroupDetectors2::formGroups( API::MatrixWorkspace_const_sptr inputWS, API::MatrixWorkspace_sptr outputWS,
const double prog4Copy)
{
// get "Behaviour" string
const std::string behaviour = getProperty("Behaviour");
int bhv = 0;
if ( behaviour == "Average" ) bhv = 1;
API::MatrixWorkspace_sptr beh = API::WorkspaceFactory::Instance().create(
"Workspace2D", static_cast<int>(m_GroupSpecInds.size()), 1, 1);
g_log.debug() << name() << ": Preparing to group spectra into " << m_GroupSpecInds.size() << " groups\n";
// where we are copying spectra to, we start copying to the start of the output workspace
size_t outIndex = 0;
// Only used for averaging behaviour. We may have a 1:1 map where a Divide would be waste as it would be just dividing by 1
bool requireDivide(false);
for ( storage_map::const_iterator it = m_GroupSpecInds.begin(); it != m_GroupSpecInds.end() ; ++it )
{
// This is the grouped spectrum
ISpectrum * outSpec = outputWS->getSpectrum(outIndex);
// The spectrum number of the group is the key
outSpec->setSpectrumNo(it->first);
// Start fresh with no detector IDs
outSpec->clearDetectorIDs();
// Copy over X data from first spectrum, the bin boundaries for all spectra are assumed to be the same here
outSpec->dataX() = inputWS->readX(0);
// the Y values and errors from spectra being grouped are combined in the output spectrum
// Keep track of number of detectors required for masking
size_t nonMaskedSpectra(0);
beh->dataX(outIndex)[0] = 0.0;
beh->dataE(outIndex)[0] = 0.0;
for( std::vector<size_t>::const_iterator wsIter = it->second.begin(); wsIter != it->second.end(); ++wsIter)
{
const size_t originalWI = *wsIter;
// detectors to add to firstSpecNum
const ISpectrum * fromSpectrum = inputWS->getSpectrum(originalWI);
// Add up all the Y spectra and store the result in the first one
// Need to keep the next 3 lines inside loop for now until ManagedWorkspace mru-list works properly
MantidVec &firstY = outSpec->dataY();
MantidVec::iterator fYit;
MantidVec::iterator fEit = outSpec->dataE().begin();
MantidVec::const_iterator Yit = fromSpectrum->dataY().begin();
MantidVec::const_iterator Eit = fromSpectrum->dataE().begin();
for (fYit = firstY.begin(); fYit != firstY.end(); ++fYit, ++fEit, ++Yit, ++Eit)
{
*fYit += *Yit;
// Assume 'normal' (i.e. Gaussian) combination of errors
*fEit = std::sqrt( (*fEit)*(*fEit) + (*Eit)*(*Eit) );
}
// detectors to add to the output spectrum
outSpec->addDetectorIDs(fromSpectrum->getDetectorIDs() );
try
{
Geometry::IDetector_const_sptr det = inputWS->getDetector(originalWI);
if( !det->isMasked() ) ++nonMaskedSpectra;
}
catch(Exception::NotFoundError&)
{
// If a detector cannot be found, it cannot be masked
++nonMaskedSpectra;
}
}
if( nonMaskedSpectra == 0 ) ++nonMaskedSpectra; // Avoid possible divide by zero
if(!requireDivide) requireDivide = (nonMaskedSpectra > 1);
beh->dataY(outIndex)[0] = static_cast<double>(nonMaskedSpectra);
// make regular progress reports and check for cancelling the algorithm
if ( outIndex % INTERVAL == 0 )
{
m_FracCompl += INTERVAL*prog4Copy;
if ( m_FracCompl > 1.0 )
m_FracCompl = 1.0;
progress(m_FracCompl);
interruption_point();
}
outIndex ++;
}
// Refresh the spectraDetectorMap
outputWS->generateSpectraMap();
if ( bhv == 1 && requireDivide )
{
g_log.debug() << "Running Divide algorithm to perform averaging.\n";
Mantid::API::IAlgorithm_sptr divide = createChildAlgorithm("Divide");
divide->initialize();
divide->setProperty<API::MatrixWorkspace_sptr>("LHSWorkspace", outputWS);
divide->setProperty<API::MatrixWorkspace_sptr>("RHSWorkspace", beh);
divide->setProperty<API::MatrixWorkspace_sptr>("OutputWorkspace", outputWS);
divide->execute();
}
g_log.debug() << name() << " created " << outIndex << " new grouped spectra\n";
return outIndex;
}
void GatherWorkspaces::exec() {
// Every process in an MPI job must hit this next line or everything hangs!
mpi::communicator world; // The communicator containing all processes
inputWorkspace = getProperty("InputWorkspace");
// Create a new communicator that includes only those processes that have an
// input workspace
const int haveWorkspace(inputWorkspace ? 1 : 0);
included = world.split(haveWorkspace);
// If the present process doesn't have an input workspace then its work is
// done
if (!haveWorkspace) {
g_log.information("No input workspace on this process, so nothing to do.");
return;
}
// Get the number of bins in each workspace and check they're all the same
numBins = inputWorkspace->blocksize();
std::vector<std::size_t> all_numBins;
all_gather(included, numBins, all_numBins);
if (std::count(all_numBins.begin(), all_numBins.end(), numBins) !=
(int)all_numBins.size()) {
// All the processes will error out if all the workspaces don't have the
// same number of bins
throw Exception::MisMatch<std::size_t>(
numBins, 0, "All input workspaces must have the same number of bins");
}
// Also check that all workspaces are either histogram or not
// N.B. boost mpi doesn't seem to like me using booleans in the all_gather
hist = inputWorkspace->isHistogramData();
std::vector<int> all_hist;
all_gather(included, hist, all_hist);
if (std::count(all_hist.begin(), all_hist.end(), hist) !=
(int)all_hist.size()) {
// All the processes will error out if we don't have either all histogram or
// all point-data workspaces
throw Exception::MisMatch<int>(
hist, 0,
"The input workspaces must be all histogram or all point data");
}
// How do we accumulate the data?
std::string accum = this->getPropertyValue("AccumulationMethod");
// Get the total number of spectra in the combined inputs
totalSpec = inputWorkspace->getNumberHistograms();
sumSpec = totalSpec;
if (accum == "Append") {
reduce(included, totalSpec, sumSpec, std::plus<std::size_t>(), 0);
} else if (accum == "Add") {
// barrier only helps when memory is too low for communication
// included.barrier();
}
eventW = boost::dynamic_pointer_cast<const EventWorkspace>(inputWorkspace);
if (eventW != NULL) {
if (getProperty("PreserveEvents")) {
// Input workspace is an event workspace. Use the other exec method
this->execEvent();
return;
}
}
// The root process needs to create a workspace of the appropriate size
MatrixWorkspace_sptr outputWorkspace;
if (included.rank() == 0) {
g_log.debug() << "Total number of spectra is " << sumSpec << "\n";
// Create the workspace for the output
outputWorkspace = WorkspaceFactory::Instance().create(
inputWorkspace, sumSpec, numBins + hist, numBins);
setProperty("OutputWorkspace", outputWorkspace);
ExperimentInfo_sptr inWS = inputWorkspace;
outputWorkspace->copyExperimentInfoFrom(inWS.get());
}
for (size_t wi = 0; wi < totalSpec; wi++) {
if (included.rank() == 0) {
const ISpectrum *inSpec = inputWorkspace->getSpectrum(wi);
if (accum == "Add") {
outputWorkspace->dataX(wi) = inputWorkspace->readX(wi);
reduce(included, inputWorkspace->readY(wi), outputWorkspace->dataY(wi),
vplus(), 0);
reduce(included, inputWorkspace->readE(wi), outputWorkspace->dataE(wi),
eplus(), 0);
} else if (accum == "Append") {
// Copy over data from own input workspace
outputWorkspace->dataX(wi) = inputWorkspace->readX(wi);
outputWorkspace->dataY(wi) = inputWorkspace->readY(wi);
outputWorkspace->dataE(wi) = inputWorkspace->readE(wi);
const int numReqs(3 * (included.size() - 1));
mpi::request reqs[numReqs];
int j(0);
// Receive data from all the other processes
// This works because the process ranks are ordered the same in
// 'included' as
// they are in 'world', but in general this is not guaranteed. TODO:
// robustify
for (int i = 1; i < included.size(); ++i) {
size_t index = wi + i * totalSpec;
reqs[j++] = included.irecv(i, 0, outputWorkspace->dataX(index));
reqs[j++] = included.irecv(i, 1, outputWorkspace->dataY(index));
reqs[j++] = included.irecv(i, 2, outputWorkspace->dataE(index));
ISpectrum *outSpec = outputWorkspace->getSpectrum(index);
outSpec->clearDetectorIDs();
outSpec->addDetectorIDs(inSpec->getDetectorIDs());
}
// Make sure everything's been received before exiting the algorithm
mpi::wait_all(reqs, reqs + numReqs);
}
ISpectrum *outSpec = outputWorkspace->getSpectrum(wi);
outSpec->clearDetectorIDs();
outSpec->addDetectorIDs(inSpec->getDetectorIDs());
} else {
if (accum == "Add") {
reduce(included, inputWorkspace->readY(wi), vplus(), 0);
reduce(included, inputWorkspace->readE(wi), eplus(), 0);
} else if (accum == "Append") {
mpi::request reqs[3];
// Send the spectrum to the root process
reqs[0] = included.isend(0, 0, inputWorkspace->readX(0));
reqs[1] = included.isend(0, 1, inputWorkspace->readY(0));
reqs[2] = included.isend(0, 2, inputWorkspace->readE(0));
// Make sure the sends have completed before exiting the algorithm
mpi::wait_all(reqs, reqs + 3);
}
}
}
}
/** Executes the algorithm
*
*/
void SumSpectra::exec()
{
// Try and retrieve the optional properties
m_MinSpec = getProperty("StartWorkspaceIndex");
m_MaxSpec = getProperty("EndWorkspaceIndex");
const std::vector<int> indices_list = getProperty("ListOfWorkspaceIndices");
keepMonitors = getProperty("IncludeMonitors");
// Get the input workspace
MatrixWorkspace_const_sptr localworkspace = getProperty("InputWorkspace");
numberOfSpectra = static_cast<int>(localworkspace->getNumberHistograms());
this->yLength = static_cast<int>(localworkspace->blocksize());
// Check 'StartSpectrum' is in range 0-numberOfSpectra
if ( m_MinSpec > numberOfSpectra )
{
g_log.warning("StartWorkspaceIndex out of range! Set to 0.");
m_MinSpec = 0;
}
if (indices_list.empty())
{
//If no list was given and no max, just do all.
if ( isEmpty(m_MaxSpec) ) m_MaxSpec = numberOfSpectra-1;
}
//Something for m_MaxSpec was given but it is out of range?
if (!isEmpty(m_MaxSpec) && ( m_MaxSpec > numberOfSpectra-1 || m_MaxSpec < m_MinSpec ))
{
g_log.warning("EndWorkspaceIndex out of range! Set to max Workspace Index");
m_MaxSpec = numberOfSpectra;
}
//Make the set of indices to sum up from the list
this->indices.insert(indices_list.begin(), indices_list.end());
//And add the range too, if any
if (!isEmpty(m_MaxSpec))
{
for (int i = m_MinSpec; i <= m_MaxSpec; i++)
this->indices.insert(i);
}
//determine the output spectrum id
m_outSpecId = this->getOutputSpecId(localworkspace);
g_log.information() << "Spectra remapping gives single spectra with spectra number: "
<< m_outSpecId << "\n";
m_CalculateWeightedSum = getProperty("WeightedSum");
EventWorkspace_const_sptr eventW = boost::dynamic_pointer_cast<const EventWorkspace>(localworkspace);
if (eventW)
{
m_CalculateWeightedSum = false;
this->execEvent(eventW, this->indices);
}
else
{
//-------Workspace 2D mode -----
// Create the 2D workspace for the output
MatrixWorkspace_sptr outputWorkspace = API::WorkspaceFactory::Instance().create(localworkspace,
1,localworkspace->readX(0).size(),this->yLength);
size_t numSpectra(0); // total number of processed spectra
size_t numMasked(0); // total number of the masked and skipped spectra
size_t numZeros(0); // number of spectra which have 0 value in the first column (used in special cases of evaluating how good Puasonian statistics is)
Progress progress(this, 0, 1, this->indices.size());
// This is the (only) output spectrum
ISpectrum * outSpec = outputWorkspace->getSpectrum(0);
// Copy over the bin boundaries
outSpec->dataX() = localworkspace->readX(0);
//Build a new spectra map
outSpec->setSpectrumNo(m_outSpecId);
outSpec->clearDetectorIDs();
if (localworkspace->id() == "RebinnedOutput")
{
this->doRebinnedOutput(outputWorkspace, progress,numSpectra,numMasked,numZeros);
}
else
{
this->doWorkspace2D(localworkspace, outSpec, progress,numSpectra,numMasked,numZeros);
}
// Pointer to sqrt function
MantidVec& YError = outSpec->dataE();
typedef double (*uf)(double);
uf rs=std::sqrt;
//take the square root of all the accumulated squared errors - Assumes Gaussian errors
std::transform(YError.begin(), YError.end(), YError.begin(), rs);
outputWorkspace->generateSpectraMap();
// set up the summing statistics
outputWorkspace->mutableRun().addProperty("NumAllSpectra",int(numSpectra),"",true);
outputWorkspace->mutableRun().addProperty("NumMaskSpectra",int(numMasked),"",true);
outputWorkspace->mutableRun().addProperty("NumZeroSpectra",int(numZeros),"",true);
// Assign it to the output workspace property
setProperty("OutputWorkspace", outputWorkspace);
}
}
void GroupDetectors::exec()
{
// Get the input workspace
const MatrixWorkspace_sptr WS = getProperty("Workspace");
std::vector<size_t> indexList = getProperty("WorkspaceIndexList");
std::vector<specid_t> spectraList = getProperty("SpectraList");
const std::vector<detid_t> detectorList = getProperty("DetectorList");
// Could create a Validator to replace the below
if ( indexList.empty() && spectraList.empty() && detectorList.empty() )
{
g_log.information(name() +
": WorkspaceIndexList, SpectraList, and DetectorList properties are all empty, no grouping done");
return;
}
// Bin boundaries need to be the same, so check if they actually are
if (!API::WorkspaceHelpers::commonBoundaries(WS))
{
g_log.error("Can only group if the histograms have common bin boundaries");
throw std::runtime_error("Can only group if the histograms have common bin boundaries");
}
// If the spectraList property has been set, need to loop over the workspace looking for the
// appropriate spectra number and adding the indices they are linked to the list to be processed
if ( ! spectraList.empty() )
{
WS->getIndicesFromSpectra(spectraList,indexList);
}// End dealing with spectraList
else if ( ! detectorList.empty() )
{
// Dealing with DetectorList
//convert from detectors to workspace indices
WS->getIndicesFromDetectorIDs(detectorList, indexList);
}
if ( indexList.empty() )
{
g_log.warning("Nothing to group");
return;
}
const size_t vectorSize = WS->blocksize();
const specid_t firstIndex = static_cast<specid_t>(indexList[0]);
ISpectrum * firstSpectrum = WS->getSpectrum(firstIndex);
setProperty("ResultIndex",firstIndex);
// loop over the spectra to group
Progress progress(this, 0.0, 1.0, static_cast<int>(indexList.size()-1));
for (size_t i = 0; i < indexList.size()-1; ++i)
{
// The current spectrum
const size_t currentIndex = indexList[i+1];
ISpectrum * spec = WS->getSpectrum(currentIndex);
// Add the current detector to belong to the first spectrum
firstSpectrum->addDetectorIDs(spec->getDetectorIDs());
// Add up all the Y spectra and store the result in the first one
// Need to keep the next 3 lines inside loop for now until ManagedWorkspace mru-list works properly
MantidVec &firstY = WS->dataY(firstIndex);
MantidVec::iterator fYit;
MantidVec::iterator fEit = firstSpectrum->dataE().begin();
MantidVec::iterator Yit = spec->dataY().begin();
MantidVec::iterator Eit = spec->dataE().begin();
for (fYit = firstY.begin(); fYit != firstY.end(); ++fYit, ++fEit, ++Yit, ++Eit)
{
*fYit += *Yit;
// Assume 'normal' (i.e. Gaussian) combination of errors
*fEit = sqrt( (*fEit)*(*fEit) + (*Eit)*(*Eit) );
}
// Now zero the now redundant spectrum and set its spectraNo to indicate this (using -1)
// N.B. Deleting spectra would cause issues for ManagedWorkspace2D, hence the the approach taken here
spec->dataY().assign(vectorSize,0.0);
spec->dataE().assign(vectorSize,0.0);
spec->setSpectrumNo(-1);
spec->clearDetectorIDs();
progress.report();
}
}
