/** Initialise a workspace from its parent
* This sets values such as title, instrument, units, sample, spectramap.
* This does NOT copy any data.
*
* @param parent :: the parent workspace
* @param child :: the child workspace
* @param differentSize :: A flag to indicate if the two workspace will be different sizes
*/
void WorkspaceFactoryImpl::initializeFromParent(const MatrixWorkspace_const_sptr parent,
const MatrixWorkspace_sptr child, const bool differentSize) const
{
child->setTitle(parent->getTitle());
child->setComment(parent->getComment());
child->setInstrument(parent->getInstrument()); // This call also copies the SHARED POINTER to the parameter map
// This call will (should) perform a COPY of the parameter map.
child->instrumentParameters();
child->m_sample = parent->m_sample;
child->m_run = parent->m_run;
child->setYUnit(parent->m_YUnit);
child->setYUnitLabel(parent->m_YUnitLabel);
child->isDistribution(parent->isDistribution());
// Only copy the axes over if new sizes are not given
if ( !differentSize )
{
// Only copy mask map if same size for now. Later will need to check continued validity.
child->m_masks = parent->m_masks;
}
// Same number of histograms = copy over the spectra data
if (parent->getNumberHistograms() == child->getNumberHistograms())
{
for (size_t wi=0; wi<parent->getNumberHistograms(); wi++)
{
ISpectrum * childSpec = child->getSpectrum(wi);
const ISpectrum * parentSpec = parent->getSpectrum(wi);
// Copy spectrum number and detector IDs
childSpec->copyInfoFrom(*parentSpec);
}
}
// deal with axis
for (size_t i = 0; i < parent->m_axes.size(); ++i)
{
const size_t newAxisLength = child->getAxis(i)->length();
const size_t oldAxisLength = parent->getAxis(i)->length();
if ( !differentSize || newAxisLength == oldAxisLength )
{
// Need to delete the existing axis created in init above
delete child->m_axes[i];
// Now set to a copy of the parent workspace's axis
child->m_axes[i] = parent->m_axes[i]->clone(child.get());
}
else
{
if (! parent->getAxis(i)->isSpectra()) // WHY???
{
delete child->m_axes[i];
// Call the 'different length' clone variant
child->m_axes[i] = parent->m_axes[i]->clone(newAxisLength,child.get());
}
}
}
return;
}
/**
* Execute the algorithm
*/
void ExtractMasking::exec()
{
MatrixWorkspace_const_sptr inputWS = getProperty("InputWorkspace");
const int nHist = static_cast<int>(inputWS->getNumberHistograms());
const int xLength(1), yLength(1);
// Create a new workspace for the results, copy from the input to ensure that we copy over the instrument and current masking
MatrixWorkspace_sptr outputWS = WorkspaceFactory::Instance().create(inputWS, nHist, xLength, yLength);
Progress prog(this,0.0,1.0,nHist);
MantidVecPtr xValues;
xValues.access() = MantidVec(1, 0.0);
PARALLEL_FOR2(inputWS, outputWS)
for( int i = 0; i < nHist; ++i )
{
PARALLEL_START_INTERUPT_REGION
// Spectrum in the output workspace
ISpectrum * outSpec = outputWS->getSpectrum(i);
// Spectrum in the input workspace
const ISpectrum * inSpec = inputWS->getSpectrum(i);
// Copy X, spectrum number and detector IDs
outSpec->setX(xValues);
outSpec->copyInfoFrom(*inSpec);
IDetector_const_sptr inputDet;
bool inputIsMasked(false);
try
{
inputDet = inputWS->getDetector(i);
if( inputDet->isMasked() )
{
inputIsMasked = true;
}
}
catch(Kernel::Exception::NotFoundError &)
{
inputIsMasked = false;
}
if( inputIsMasked )
{
outSpec->dataY()[0] = 0.0;
outSpec->dataE()[0] = 0.0;
}
else
{
outSpec->dataY()[0] = 1.0;
outSpec->dataE()[0] = 1.0;
}
prog.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
setProperty("OutputWorkspace", outputWS);
}
void ConvertToMatrixWorkspace::exec()
{
MatrixWorkspace_const_sptr inputWorkspace = getProperty("InputWorkspace");
// Let's see if we have to do anything first. Basically we want to avoid the data copy if we can
DataObjects::EventWorkspace_const_sptr eventW =
boost::dynamic_pointer_cast<const DataObjects::EventWorkspace>(inputWorkspace);
MatrixWorkspace_sptr outputWorkspace;
if( eventW )
{
g_log.information() << "Converting EventWorkspace to Workspace2D.\n";
const size_t numHists = inputWorkspace->getNumberHistograms();
Progress prog(this,0.0,1.0,numHists*2);
// Sort the input workspace in-place by TOF. This can be faster if there are few event lists.
eventW->sortAll(TOF_SORT, &prog);
// Create the output workspace. This will copy many aspects fron the input one.
outputWorkspace = WorkspaceFactory::Instance().create(inputWorkspace);
// ...but not the data, so do that here.
PARALLEL_FOR2(inputWorkspace,outputWorkspace)
for (int64_t i = 0; i < (int64_t)numHists; ++i)
{
PARALLEL_START_INTERUPT_REGION
const ISpectrum * inSpec = inputWorkspace->getSpectrum(i);
ISpectrum * outSpec = outputWorkspace->getSpectrum(i);
outSpec->copyInfoFrom(*inSpec);
outSpec->setX(inSpec->ptrX());
outSpec->dataY() = inSpec->dataY();
outSpec->dataE() = inSpec->dataE();
prog.report("Binning");
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
outputWorkspace->generateSpectraMap();
}
else
{
/** Executes the algorithm
* @throw std::invalid_argument If the input workspaces do not meet the requirements of this algorithm
*/
void ConjoinWorkspaces::exec()
{
// Retrieve the input workspaces
MatrixWorkspace_const_sptr ws1 = getProperty("InputWorkspace1");
MatrixWorkspace_const_sptr ws2 = getProperty("InputWorkspace2");
event_ws1 = boost::dynamic_pointer_cast<const EventWorkspace>(ws1);
event_ws2 = boost::dynamic_pointer_cast<const EventWorkspace>(ws2);
//Make sure that we are not mis-matching EventWorkspaces and other types of workspaces
if (((event_ws1) && (!event_ws2)) || ((!event_ws1) && (event_ws2)))
{
const std::string message("Only one of the input workspaces are of type EventWorkspace; please use matching workspace types (both EventWorkspace's or both Workspace2D's).");
g_log.error(message);
throw std::invalid_argument(message);
}
if (event_ws1 && event_ws2)
{
//Both are event workspaces. Use the special method
this->execEvent();
return;
}
// Check that the input workspaces meet the requirements for this algorithm
this->validateInputs(ws1,ws2);
// Create the output workspace
const size_t totalHists = ws1->getNumberHistograms() + ws2->getNumberHistograms();
MatrixWorkspace_sptr output = WorkspaceFactory::Instance().create("Workspace2D",totalHists,ws1->readX(0).size(),
ws1->readY(0).size());
// Copy over stuff from first input workspace
WorkspaceFactory::Instance().initializeFromParent(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() = ws1->readX(0);
// Initialize the progress reporting object
m_progress = new API::Progress(this, 0.0, 1.0, totalHists);
// Loop over the input workspaces in turn copying the data into the output one
const int64_t& nhist1 = ws1->getNumberHistograms();
PARALLEL_FOR2(ws1, output)
for (int64_t i = 0; i < nhist1; ++i)
{
PARALLEL_START_INTERUPT_REGION
ISpectrum * outSpec = output->getSpectrum(i);
const ISpectrum * inSpec = ws1->getSpectrum(i);
// Copy X,Y,E
outSpec->setX(XValues);
outSpec->setData(inSpec->dataY(), inSpec->dataE());
// Copy the spectrum number/detector IDs
outSpec->copyInfoFrom(*inSpec);
// Propagate masking, if needed
if ( ws1->hasMaskedBins(i) )
{
const MatrixWorkspace::MaskList& inputMasks = ws1->maskedBins(i);
MatrixWorkspace::MaskList::const_iterator it;
for (it = inputMasks.begin(); it != inputMasks.end(); ++it)
{
output->flagMasked(i,(*it).first,(*it).second);
}
}
m_progress->report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
//For second loop we use the offset from the first
const int64_t& nhist2 = ws2->getNumberHistograms();
PARALLEL_FOR2(ws2, output)
for (int64_t j = 0; j < nhist2; ++j)
{
PARALLEL_START_INTERUPT_REGION
// The spectrum in the output workspace
ISpectrum * outSpec = output->getSpectrum(nhist1 + j);
// Spectrum in the second workspace
const ISpectrum * inSpec = ws2->getSpectrum(j);
// Copy X,Y,E
outSpec->setX(XValues);
outSpec->setData(inSpec->dataY(), inSpec->dataE());
// Copy the spectrum number/detector IDs
outSpec->copyInfoFrom(*inSpec);
// Propagate masking, if needed
if ( ws2->hasMaskedBins(j) )
{
const MatrixWorkspace::MaskList& inputMasks = ws2->maskedBins(j);
MatrixWorkspace::MaskList::const_iterator it;
for (it = inputMasks.begin(); it != inputMasks.end(); ++it)
{
output->flagMasked(nhist1 + j,(*it).first,(*it).second);
}
}
m_progress->report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
this->fixSpectrumNumbers(ws1,ws2, output);
// Delete the second input workspace from the ADS
AnalysisDataService::Instance().remove(getPropertyValue("InputWorkspace2"));
// Set the result workspace to the first input
setProperty("InputWorkspace1",output);
}
