/** Executes the algorithm
* @throw std::invalid_argument If the input workspaces do not meet the requirements of this algorithm
*/
void ConjoinWorkspaces::execEvent()
{
//We do not need to check that binning is compatible, just that there is no overlap
this->checkForOverlap(event_ws1, event_ws2, false);
// Create the output workspace
const size_t totalHists = event_ws1->getNumberHistograms() + event_ws2->getNumberHistograms();
// Have the minimum # of histograms in the output.
EventWorkspace_sptr output = boost::dynamic_pointer_cast<EventWorkspace>(
WorkspaceFactory::Instance().create("EventWorkspace",
1, event_ws1->readX(0).size(), event_ws1->readY(0).size())
);
// Copy over geometry (but not data) from first input workspace
WorkspaceFactory::Instance().initializeFromParent(event_ws1,output,true);
// Create the X values inside a cow pointer - they will be shared in the output workspace
cow_ptr<MantidVec> XValues;
XValues.access() = event_ws1->readX(0);
// Initialize the progress reporting object
m_progress = new API::Progress(this, 0.0, 1.0, totalHists);
const int64_t& nhist1 = event_ws1->getNumberHistograms();
for (int64_t i = 0; i < nhist1; ++i)
{
//Copy the events over
output->getOrAddEventList(i) = event_ws1->getEventList(i); //Should fire the copy constructor
m_progress->report();
}
//For second loop we use the offset from the first
const int64_t& nhist2 = event_ws2->getNumberHistograms();
for (int64_t j = 0; j < nhist2; ++j)
{
//This is the workspace index at which we assign in the output
int64_t output_wi = j + nhist1;
//Copy the events over
output->getOrAddEventList(output_wi) = event_ws2->getEventList(j); //Should fire the copy constructor
m_progress->report();
}
//This will make the spectramap axis.
output->doneAddingEventLists();
//Set the same bins for all output pixels
output->setAllX(XValues);
this->fixSpectrumNumbers(event_ws1, event_ws2, output);
// Delete the input workspaces from the ADS
AnalysisDataService::Instance().remove(getPropertyValue("InputWorkspace1"));
AnalysisDataService::Instance().remove(getPropertyValue("InputWorkspace2"));
// Create & assign an output workspace property with the workspace name the same as the first input
declareProperty(new WorkspaceProperty<>("Output",getPropertyValue("InputWorkspace1"),Direction::Output));
setProperty("Output", boost::dynamic_pointer_cast<MatrixWorkspace>(output) );
}
/** Load the event_workspace field
*
* @param wksp_cls
* @param progressStart
* @param progressRange
* @return
*/
API::MatrixWorkspace_sptr LoadNexusProcessed::loadEventEntry(NXData & wksp_cls, NXDouble & xbins,
const double& progressStart, const double& progressRange)
{
NXDataSetTyped<int64_t> indices_data = wksp_cls.openNXDataSet<int64_t>("indices");
indices_data.load();
boost::shared_array<int64_t> indices = indices_data.sharedBuffer();
int numspec = indices_data.dim0()-1;
int num_xbins = xbins.dim0();
if (num_xbins < 2) num_xbins = 2;
EventWorkspace_sptr ws = boost::dynamic_pointer_cast<EventWorkspace>
(WorkspaceFactory::Instance().create("EventWorkspace", numspec, num_xbins, num_xbins-1));
// Set the YUnit label
ws->setYUnit(indices_data.attributes("units"));
std::string unitLabel = indices_data.attributes("unit_label");
if (unitLabel.empty()) unitLabel = indices_data.attributes("units");
ws->setYUnitLabel(unitLabel);
//Handle optional fields.
// TODO: Handle inconsistent sizes
boost::shared_array<int64_t> pulsetimes;
if (wksp_cls.isValid("pulsetime"))
{
NXDataSetTyped<int64_t> pulsetime = wksp_cls.openNXDataSet<int64_t>("pulsetime");
pulsetime.load();
pulsetimes = pulsetime.sharedBuffer();
}
boost::shared_array<double> tofs;
if (wksp_cls.isValid("tof"))
{
NXDouble tof = wksp_cls.openNXDouble("tof");
tof.load();
tofs = tof.sharedBuffer();
}
boost::shared_array<float> error_squareds;
if (wksp_cls.isValid("error_squared"))
{
NXFloat error_squared = wksp_cls.openNXFloat("error_squared");
error_squared.load();
error_squareds = error_squared.sharedBuffer();
}
boost::shared_array<float> weights;
if (wksp_cls.isValid("weight"))
{
NXFloat weight = wksp_cls.openNXFloat("weight");
weight.load();
weights = weight.sharedBuffer();
}
// What type of event lists?
EventType type = TOF;
if (tofs && pulsetimes && weights && error_squareds)
type = WEIGHTED;
else if ((tofs && weights && error_squareds))
type = WEIGHTED_NOTIME;
else if (pulsetimes && tofs)
type = TOF;
else
throw std::runtime_error("Could not figure out the type of event list!");
// Create all the event lists
PARALLEL_FOR_NO_WSP_CHECK()
for (int wi=0; wi < numspec; wi++)
{
PARALLEL_START_INTERUPT_REGION
int64_t index_start = indices[wi];
int64_t index_end = indices[wi+1];
if (index_end >= index_start)
{
EventList & el = ws->getEventList(wi);
el.switchTo(type);
// Allocate all the required memory
el.reserve(index_end - index_start);
el.clearDetectorIDs();
for (long i=index_start; i<index_end; i++)
switch (type)
{
case TOF:
el.addEventQuickly( TofEvent( tofs[i], DateAndTime(pulsetimes[i])) );
break;
case WEIGHTED:
el.addEventQuickly( WeightedEvent( tofs[i], DateAndTime(pulsetimes[i]), weights[i], error_squareds[i]) );
break;
case WEIGHTED_NOTIME:
el.addEventQuickly( WeightedEventNoTime( tofs[i], weights[i], error_squareds[i]) );
break;
}
// Set the X axis
if (this->m_shared_bins)
el.setX(this->m_xbins);
else
{
MantidVec x;
x.resize(xbins.dim0());
for (int i=0; i < xbins.dim0(); i++)
x[i] = xbins(wi, i);
el.setX(x);
}
}
progress(progressStart + progressRange*(1.0/numspec));
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
// Clean up some stuff
ws->doneAddingEventLists();
return ws;
}
/** Executes the algorithm
*@param localworkspace :: the input workspace
*@param indices :: set of indices to sum up
*/
void SumSpectra::execEvent(EventWorkspace_const_sptr localworkspace, std::set<int> &indices)
{
//Make a brand new EventWorkspace
EventWorkspace_sptr outputWorkspace = boost::dynamic_pointer_cast<EventWorkspace>(
API::WorkspaceFactory::Instance().create("EventWorkspace", 1, 2, 1));
//Copy geometry over.
API::WorkspaceFactory::Instance().initializeFromParent(localworkspace, outputWorkspace, true);
Progress progress(this,0,1, indices.size());
//Get the pointer to the output event list
EventList & outEL = outputWorkspace->getEventList(0);
outEL.setSpectrumNo(m_outSpecId);
outEL.clearDetectorIDs();
// Loop over spectra
std::set<int>::iterator it;
size_t numSpectra(0);
size_t numMasked(0);
size_t numZeros(0);
//for (int i = m_MinSpec; i <= m_MaxSpec; ++i)
for (it = indices.begin(); it != indices.end(); ++it)
{
int i = *it;
//Don't go outside the range.
if ((i >= numberOfSpectra) || (i < 0))
{
g_log.error() << "Invalid index " << i << " was specified. Sum was aborted.\n";
break;
}
try
{
// Get the detector object for this spectrum
Geometry::IDetector_const_sptr det = localworkspace->getDetector(i);
// Skip monitors, if the property is set to do so
if ( !keepMonitors && det->isMonitor() ) continue;
// Skip masked detectors
if ( det->isMasked() )
{
numMasked++;
continue;
}
}
catch(...)
{
// if the detector not found just carry on
}
numSpectra++;
//Add the event lists with the operator
const EventList & tOutEL = localworkspace->getEventList(i);
if(tOutEL.empty())
numZeros++;
else
outEL += tOutEL;
progress.report();
}
//Finalize spectra map etc.
outputWorkspace->doneAddingEventLists();
//Set all X bins on the output
cow_ptr<MantidVec> XValues;
XValues.access() = localworkspace->readX(0);
outputWorkspace->setAllX(XValues);
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",boost::dynamic_pointer_cast<MatrixWorkspace>(outputWorkspace));
}
