/**
* 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
{
/** Load a single bank into the workspace
*
* @param nexusfilename :: file to open
* @param entry_name :: NXentry name
* @param bankName :: NXdata bank name
* @param WS :: workspace to modify
* @param id_to_wi :: det ID to workspace index mapping
*/
void LoadTOFRawNexus::loadBank(const std::string &nexusfilename,
const std::string &entry_name,
const std::string &bankName,
API::MatrixWorkspace_sptr WS,
const detid2index_map &id_to_wi) {
g_log.debug() << "Loading bank " << bankName << std::endl;
// To avoid segfaults on RHEL5/6 and Fedora
m_fileMutex.lock();
// Navigate to the point in the file
auto file = new ::NeXus::File(nexusfilename);
file->openGroup(entry_name, "NXentry");
file->openGroup("instrument", "NXinstrument");
file->openGroup(bankName, "NXdetector");
size_t m_numPixels = 0;
std::vector<uint32_t> pixel_id;
if (!m_assumeOldFile) {
// Load the pixel IDs
file->readData("pixel_id", pixel_id);
m_numPixels = pixel_id.size();
if (m_numPixels == 0) {
file->close();
m_fileMutex.unlock();
g_log.warning() << "Invalid pixel_id data in " << bankName << std::endl;
return;
}
} else {
// Load the x and y pixel offsets
std::vector<float> xoffsets;
std::vector<float> yoffsets;
file->readData("x_pixel_offset", xoffsets);
file->readData("y_pixel_offset", yoffsets);
m_numPixels = xoffsets.size() * yoffsets.size();
if (0 == m_numPixels) {
file->close();
m_fileMutex.unlock();
g_log.warning() << "Invalid (x,y) offsets in " << bankName << std::endl;
return;
}
size_t bankNum = 0;
if (bankName.size() > 4) {
if (bankName.substr(0, 4) == "bank") {
bankNum = boost::lexical_cast<size_t>(bankName.substr(4));
bankNum--;
} else {
file->close();
m_fileMutex.unlock();
g_log.warning() << "Invalid bank number for " << bankName << std::endl;
return;
}
}
// All good, so construct the pixel ID listing
size_t numX = xoffsets.size();
size_t numY = yoffsets.size();
for (size_t i = 0; i < numX; i++) {
for (size_t j = 0; j < numY; j++) {
pixel_id.push_back(
static_cast<uint32_t>(j + numY * (i + numX * bankNum)));
}
}
}
size_t iPart = 0;
if (m_spec_max != Mantid::EMPTY_INT()) {
uint32_t ifirst = pixel_id[0];
range_check out_range(m_spec_min, m_spec_max, id_to_wi);
auto newEnd = std::remove_if(pixel_id.begin(), pixel_id.end(), out_range);
pixel_id.erase(newEnd, pixel_id.end());
// check if beginning or end of array was erased
if (ifirst != pixel_id[0])
iPart = m_numPixels - pixel_id.size();
m_numPixels = pixel_id.size();
if (m_numPixels == 0) {
file->close();
m_fileMutex.unlock();
g_log.warning() << "No pixels from " << bankName << std::endl;
return;
};
}
// Load the TOF vector
std::vector<float> tof;
file->readData(m_axisField, tof);
size_t m_numBins = tof.size() - 1;
if (tof.size() <= 1) {
file->close();
m_fileMutex.unlock();
g_log.warning() << "Invalid " << m_axisField << " data in " << bankName
<< std::endl;
return;
}
// Make a shared pointer
MantidVecPtr Xptr;
MantidVec &X = Xptr.access();
X.resize(tof.size(), 0);
X.assign(tof.begin(), tof.end());
// Load the data. Coerce ints into double.
std::string errorsField = "";
std::vector<double> data;
file->openData(m_dataField);
file->getDataCoerce(data);
if (file->hasAttr("errors"))
file->getAttr("errors", errorsField);
file->closeData();
// Load the errors
bool hasErrors = !errorsField.empty();
std::vector<double> errors;
if (hasErrors) {
try {
file->openData(errorsField);
file->getDataCoerce(errors);
file->closeData();
} catch (...) {
g_log.information() << "Error loading the errors field, '" << errorsField
<< "' for bank " << bankName
<< ". Will use sqrt(counts). " << std::endl;
hasErrors = false;
}
}
/*if (data.size() != m_numBins * m_numPixels)
{ file->close(); m_fileMutex.unlock(); g_log.warning() << "Invalid size of '"
<< m_dataField << "' data in " << bankName << std::endl; return; }
if (hasErrors && (errors.size() != m_numBins * m_numPixels))
{ file->close(); m_fileMutex.unlock(); g_log.warning() << "Invalid size of '"
<< errorsField << "' errors in " << bankName << std::endl; return; }
*/
// Have all the data I need
m_fileMutex.unlock();
file->close();
for (size_t i = iPart; i < iPart + m_numPixels; i++) {
// Find the workspace index for this detector
detid_t pixelID = pixel_id[i - iPart];
size_t wi = id_to_wi.find(pixelID)->second;
// Set the basic info of that spectrum
ISpectrum *spec = WS->getSpectrum(wi);
spec->setSpectrumNo(specid_t(wi + 1));
spec->setDetectorID(pixel_id[i - iPart]);
// Set the shared X pointer
spec->setX(X);
// Extract the Y
MantidVec &Y = spec->dataY();
Y.assign(data.begin() + i * m_numBins, data.begin() + (i + 1) * m_numBins);
MantidVec &E = spec->dataE();
if (hasErrors) {
// Copy the errors from the loaded document
E.assign(errors.begin() + i * m_numBins,
errors.begin() + (i + 1) * m_numBins);
} else {
// Now take the sqrt(Y) to give E
E = Y;
std::transform(E.begin(), E.end(), E.begin(), (double (*)(double))sqrt);
}
}
// Done!
}
/** 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);
}