/** Executes the algorithm. Reading in the file and creating and populating
* the output workspace
*
* @throw Exception::FileError If the Nexus file cannot be found/opened
* @throw std::invalid_argument If the optional properties are set to invalid
*values
*/
void LoadTOFRawNexus::exec() {
// The input properties
std::string filename = getPropertyValue("Filename");
m_signalNo = getProperty("Signal");
m_spec_min = getProperty("SpectrumMin");
m_spec_max = getProperty("SpectrumMax");
// Find the entry name we want.
std::string entry_name = LoadTOFRawNexus::getEntryName(filename);
// Count pixels and other setup
auto prog = new Progress(this, 0.0, 1.0, 10);
prog->doReport("Counting pixels");
std::vector<std::string> bankNames;
countPixels(filename, entry_name, bankNames);
g_log.debug() << "Workspace found to have " << m_numPixels << " pixels and "
<< m_numBins << " bins" << std::endl;
prog->setNumSteps(bankNames.size() + 5);
prog->doReport("Creating workspace");
// Start with a dummy WS just to hold the logs and load the instrument
MatrixWorkspace_sptr WS = WorkspaceFactory::Instance().create(
"Workspace2D", m_numPixels, m_numBins + 1, m_numBins);
// Load the logs
prog->doReport("Loading DAS logs");
g_log.debug() << "Loading DAS logs" << std::endl;
int nPeriods = 1; // Unused
std::unique_ptr<const TimeSeriesProperty<int>> periodLog(
new const TimeSeriesProperty<int>("period_log")); // Unused
LoadEventNexus::runLoadNexusLogs<MatrixWorkspace_sptr>(
filename, WS, *this, false, nPeriods, periodLog);
// Load the instrument
prog->report("Loading instrument");
g_log.debug() << "Loading instrument" << std::endl;
LoadEventNexus::runLoadInstrument<MatrixWorkspace_sptr>(filename, WS,
entry_name, this);
// Load the meta data, but don't stop on errors
prog->report("Loading metadata");
g_log.debug() << "Loading metadata" << std::endl;
try {
LoadEventNexus::loadEntryMetadata(filename, WS, entry_name);
} catch (std::exception &e) {
g_log.warning() << "Error while loading meta data: " << e.what()
<< std::endl;
}
// Set the spectrum number/detector ID at each spectrum. This is consistent
// with LoadEventNexus for non-ISIS files.
prog->report("Building Spectra Mapping");
g_log.debug() << "Building Spectra Mapping" << std::endl;
WS->rebuildSpectraMapping(false);
// And map ID to WI
g_log.debug() << "Mapping ID to WI" << std::endl;
const auto id_to_wi = WS->getDetectorIDToWorkspaceIndexMap();
// Load each bank sequentially
// PARALLEL_FOR1(WS)
for (auto bankName : bankNames) {
// PARALLEL_START_INTERUPT_REGION
prog->report("Loading bank " + bankName);
g_log.debug() << "Loading bank " << bankName << std::endl;
loadBank(filename, entry_name, bankName, WS, id_to_wi);
// PARALLEL_END_INTERUPT_REGION
}
// PARALLEL_CHECK_INTERUPT_REGION
// Set some units
if (m_xUnits == "Ang")
WS->getAxis(0)->setUnit("dSpacing");
else if (m_xUnits == "invAng")
WS->getAxis(0)->setUnit("MomentumTransfer");
else
// Default to TOF for any other string
WS->getAxis(0)->setUnit("TOF");
WS->setYUnit("Counts");
// Set to the output
setProperty("OutputWorkspace", WS);
delete prog;
}
/** Executes the algorithm. Reading in the file and creating and populating
* the output workspace
*
* @throw std::runtime_error If the instrument cannot be loaded by the LoadInstrument ChildAlgorithm
* @throw InstrumentDefinitionError Thrown if issues with the content of XML instrument file not covered by LoadInstrument
* @throw std::invalid_argument If the optional properties are set to invalid values
*/
void LoadEmptyInstrument::exec()
{
// Get other properties
const double detector_value = getProperty("DetectorValue");
const double monitor_value = getProperty("MonitorValue");
// load the instrument into this workspace
MatrixWorkspace_sptr ws = this->runLoadInstrument();
Instrument_const_sptr instrument = ws->getInstrument();
// Get number of detectors stored in instrument
const size_t number_spectra = instrument->getNumberDetectors();
// Check that we have some spectra for the workspace
if( number_spectra == 0){
g_log.error("Instrument has no detectors, unable to create workspace for it");
throw Kernel::Exception::InstrumentDefinitionError("No detectors found in instrument");
}
bool MakeEventWorkspace = getProperty("MakeEventWorkspace");
MatrixWorkspace_sptr outWS;
if (MakeEventWorkspace)
{
//Make a brand new EventWorkspace
EventWorkspace_sptr localWorkspace = boost::dynamic_pointer_cast<EventWorkspace>(
API::WorkspaceFactory::Instance().create("EventWorkspace", number_spectra, 2, 1));
//Copy geometry over.
API::WorkspaceFactory::Instance().initializeFromParent(ws, localWorkspace, true);
// Cast to matrix WS
outWS = boost::dynamic_pointer_cast<MatrixWorkspace>(localWorkspace);
}
else
{
// Now create the outputworkspace and copy over the instrument object
DataObjects::Workspace2D_sptr localWorkspace =
boost::dynamic_pointer_cast<DataObjects::Workspace2D>(WorkspaceFactory::Instance().create(ws,number_spectra,2,1));
outWS = boost::dynamic_pointer_cast<MatrixWorkspace>(localWorkspace);
}
outWS->rebuildSpectraMapping( true /* include monitors */);
// ---- Set the values ----------
if (!MakeEventWorkspace)
{
MantidVecPtr x,v,v_monitor;
x.access().resize(2); x.access()[0]=1.0; x.access()[1]=2.0;
v.access().resize(1); v.access()[0]=detector_value;
v_monitor.access().resize(1); v_monitor.access()[0]=monitor_value;
for (size_t i=0; i < outWS->getNumberHistograms(); i++)
{
IDetector_const_sptr det = outWS->getDetector(i);
if ( det->isMonitor() )
outWS->setData(i, v_monitor, v_monitor);
else
outWS->setData(i, v, v);
}
}
// Save in output
this->setProperty("OutputWorkspace", outWS);
}
