/**
* Perform a call to nxgetslab, via the NexusClasses wrapped methods for a given blocksize. The xbins are read along with
* each call to the data/error loading
* @param data :: The NXDataSet object of y values
* @param errors :: The NXDataSet object of error values
* @param xbins :: The xbin NXDataSet
* @param blocksize :: The blocksize to use
* @param nchannels :: The number of channels for the block
* @param hist :: The workspace index to start reading into
* @param wsIndex :: The workspace index to save data into
* @param local_workspace :: A pointer to the workspace
*/
void LoadNexusProcessed::loadBlock(NXDataSetTyped<double> & data, NXDataSetTyped<double> & errors, NXDouble & xbins,
int64_t blocksize, int64_t nchannels, int64_t &hist, int64_t& wsIndex,
API::MatrixWorkspace_sptr local_workspace)
{
data.load(static_cast<int>(blocksize),static_cast<int>(hist));
double *data_start = data();
double *data_end = data_start + nchannels;
errors.load(static_cast<int>(blocksize),static_cast<int>(hist));
double *err_start = errors();
double *err_end = err_start + nchannels;
xbins.load(static_cast<int>(blocksize),static_cast<int>(hist));
const int64_t nxbins(nchannels + 1);
double *xbin_start = xbins();
double *xbin_end = xbin_start + nxbins;
int64_t final(hist + blocksize);
while( hist < final )
{
MantidVec& Y = local_workspace->dataY(wsIndex);
Y.assign(data_start, data_end);
data_start += nchannels; data_end += nchannels;
MantidVec& E = local_workspace->dataE(wsIndex);
E.assign(err_start, err_end);
err_start += nchannels; err_end += nchannels;
MantidVec& X = local_workspace->dataX(wsIndex);
X.assign(xbin_start, xbin_end);
xbin_start += nxbins; xbin_end += nxbins;
++hist;
++wsIndex;
}
}
/**
* Perform a call to nxgetslab, via the NexusClasses wrapped methods for a given
* block-size
* @param data :: The NXDataSet object
* @param blocksize :: The block-size to use
* @param period :: The period number
* @param start :: The index within the file to start reading from (zero based)
* @param hist :: The workspace index to start reading into
* @param spec_num :: The spectrum number that matches the hist variable
* @param local_workspace :: The workspace to fill the data with
*/
void LoadISISNexus2::loadBlock(NXDataSetTyped<int> &data, int64_t blocksize,
int64_t period, int64_t start, int64_t &hist,
int64_t &spec_num,
DataObjects::Workspace2D_sptr &local_workspace) {
data.load(static_cast<int>(blocksize), static_cast<int>(period),
static_cast<int>(start)); // TODO this is just wrong
int *data_start = data();
int *data_end = data_start + m_loadBlockInfo.numberOfChannels;
int64_t final(hist + blocksize);
while (hist < final) {
m_progress->report("Loading data");
MantidVec &Y = local_workspace->dataY(hist);
Y.assign(data_start, data_end);
data_start += m_detBlockInfo.numberOfChannels;
data_end += m_detBlockInfo.numberOfChannels;
MantidVec &E = local_workspace->dataE(hist);
std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt);
// Populate the workspace. Loop starts from 1, hence i-1
local_workspace->setX(hist, m_tof_data);
if (m_load_selected_spectra) {
// local_workspace->getAxis(1)->setValue(hist,
// static_cast<specid_t>(spec_num));
auto spec = local_workspace->getSpectrum(hist);
specid_t specID = m_specInd2specNum_map.at(hist);
// set detectors corresponding to spectra Number
spec->setDetectorIDs(m_spec2det_map.getDetectorIDsForSpectrumNo(specID));
// set correct spectra Number
spec->setSpectrumNo(specID);
}
++hist;
++spec_num;
}
}
/**
* Perform a call to nxgetslab, via the NexusClasses wrapped methods for a given blocksize. This assumes that the
* xbins have alread been cached
* @param data :: The NXDataSet object of y values
* @param errors :: The NXDataSet object of error values
* @param blocksize :: The blocksize to use
* @param nchannels :: The number of channels for the block
* @param hist :: The workspace index to start reading into
* @param local_workspace :: A pointer to the workspace
*/
void LoadNexusProcessed::loadBlock(NXDataSetTyped<double> & data, NXDataSetTyped<double> & errors,
int64_t blocksize, int64_t nchannels, int64_t &hist,
API::MatrixWorkspace_sptr local_workspace)
{
data.load(static_cast<int>(blocksize),static_cast<int>(hist));
errors.load(static_cast<int>(blocksize),static_cast<int>(hist));
double *data_start = data();
double *data_end = data_start + nchannels;
double *err_start = errors();
double *err_end = err_start + nchannels;
int64_t final(hist + blocksize);
while( hist < final )
{
MantidVec& Y = local_workspace->dataY(hist);
Y.assign(data_start, data_end);
data_start += nchannels; data_end += nchannels;
MantidVec& E = local_workspace->dataE(hist);
E.assign(err_start, err_end);
err_start += nchannels; err_end += nchannels;
local_workspace->setX(hist, m_xbins);
++hist;
}
}
/**
* Perform a call to nxgetslab, via the NexusClasses wrapped methods for a given blocksize
* @param data :: The NXDataSet object
* @param blocksize :: The blocksize to use
* @param period :: The period number
* @param start :: The index within the file to start reading from (zero based)
* @param hist :: The workspace index to start reading into
* @param spec_num :: The spectrum number that matches the hist variable
* @param local_workspace :: The workspace to fill the data with
*/
void LoadISISNexus2::loadBlock(NXDataSetTyped<int> & data, int64_t blocksize, int64_t period, int64_t start,
int64_t &hist, int64_t& spec_num,
DataObjects::Workspace2D_sptr local_workspace)
{
data.load(static_cast<int>(blocksize), static_cast<int>(period), static_cast<int>(start)); // TODO this is just wrong
int *data_start = data();
int *data_end = data_start + m_numberOfChannels;
int64_t final(hist + blocksize);
while( hist < final )
{
m_progress->report("Loading data");
MantidVec& Y = local_workspace->dataY(hist);
Y.assign(data_start, data_end);
data_start += m_numberOfChannels; data_end += m_numberOfChannels;
MantidVec& E = local_workspace->dataE(hist);
std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt);
// Populate the workspace. Loop starts from 1, hence i-1
local_workspace->setX(hist, m_tof_data);
local_workspace->getAxis(1)->spectraNo(hist)= static_cast<specid_t>(spec_num);
++hist;
++spec_num;
}
}
/**
* Load a single entry into a workspace
* @param root :: The opened root node
* @param entry_name :: The entry name
* @param progressStart :: The percentage value to start the progress reporting for this entry
* @param progressRange :: The percentage range that the progress reporting should cover
* @returns A 2D workspace containing the loaded data
*/
API::Workspace_sptr LoadNexusProcessed::loadEntry(NXRoot & root, const std::string & entry_name,
const double& progressStart, const double& progressRange)
{
progress(progressStart,"Opening entry " + entry_name + "...");
NXEntry mtd_entry = root.openEntry(entry_name);
if (mtd_entry.containsGroup("table_workspace"))
{
return loadTableEntry(mtd_entry);
}
bool isEvent = false;
std::string group_name = "workspace";
if (mtd_entry.containsGroup("event_workspace"))
{
isEvent = true;
group_name = "event_workspace";
}
// Get workspace characteristics
NXData wksp_cls = mtd_entry.openNXData(group_name);
// Axis information
// "X" axis
NXDouble xbins = wksp_cls.openNXDouble("axis1");
xbins.load();
std::string unit1 = xbins.attributes("units");
// Non-uniform x bins get saved as a 2D 'axis1' dataset
int xlength(-1);
if( xbins.rank() == 2 )
{
xlength = xbins.dim1();
m_shared_bins = false;
}
else if( xbins.rank() == 1 )
{
xlength = xbins.dim0();
m_shared_bins = true;
xbins.load();
m_xbins.access().assign(xbins(), xbins() + xlength);
}
else
{
throw std::runtime_error("Unknown axis1 dimension encountered.");
}
// MatrixWorkspace axis 1
NXDouble axis2 = wksp_cls.openNXDouble("axis2");
std::string unit2 = axis2.attributes("units");
// The workspace being worked on
API::MatrixWorkspace_sptr local_workspace;
size_t nspectra;
int64_t nchannels;
// -------- Process as event ? --------------------
if (isEvent)
{
local_workspace = loadEventEntry(wksp_cls, xbins, progressStart, progressRange);
nspectra = local_workspace->getNumberHistograms();
nchannels = local_workspace->blocksize();
}
else
{
NXDataSetTyped<double> data = wksp_cls.openDoubleData();
nspectra = data.dim0();
nchannels = data.dim1();
//// validate the optional spectrum parameters, if set
checkOptionalProperties(nspectra);
// Actual number of spectra in output workspace (if only a range was going to be loaded)
int total_specs=calculateWorkspacesize(nspectra);
//// Create the 2D workspace for the output
local_workspace = boost::dynamic_pointer_cast<API::MatrixWorkspace>
(WorkspaceFactory::Instance().create("Workspace2D", total_specs, xlength, nchannels));
try
{
local_workspace->setTitle(mtd_entry.getString("title"));
}
catch (std::runtime_error&)
{
g_log.debug() << "No title was found in the input file, " << getPropertyValue("Filename") << std::endl;
}
// Set the YUnit label
local_workspace->setYUnit(data.attributes("units"));
std::string unitLabel = data.attributes("unit_label");
if (unitLabel.empty()) unitLabel = data.attributes("units");
local_workspace->setYUnitLabel(unitLabel);
readBinMasking(wksp_cls, local_workspace);
NXDataSetTyped<double> errors = wksp_cls.openNXDouble("errors");
int64_t blocksize(8);
//const int fullblocks = nspectra / blocksize;
//size of the workspace
int64_t fullblocks = total_specs / blocksize;
int64_t read_stop = (fullblocks * blocksize);
const double progressBegin = progressStart+0.25*progressRange;
const double progressScaler = 0.75*progressRange;
int64_t hist_index = 0;
int64_t wsIndex=0;
if( m_shared_bins )
{
//if spectrum min,max,list properties are set
if(m_interval||m_list)
{
//if spectrum max,min properties are set read the data as a block(multiple of 8) and
//then read the remaining data as finalblock
if(m_interval)
{
//specs at the min-max interval
int interval_specs=static_cast<int>(m_spec_max-m_spec_min);
fullblocks=(interval_specs)/blocksize;
read_stop = (fullblocks * blocksize)+m_spec_min-1;
if(interval_specs<blocksize)
{
blocksize=total_specs;
read_stop=m_spec_max-1;
}
hist_index=m_spec_min-1;
for( ; hist_index < read_stop; )
{
progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data...");
loadBlock(data, errors, blocksize, nchannels, hist_index,wsIndex, local_workspace);
}
int64_t finalblock = m_spec_max-1 - read_stop;
if( finalblock > 0 )
{
loadBlock(data, errors, finalblock, nchannels, hist_index,wsIndex,local_workspace);
}
}
// if spectrum list property is set read each spectrum separately by setting blocksize=1
if(m_list)
{
std::vector<int64_t>::iterator itr=m_spec_list.begin();
for(;itr!=m_spec_list.end();++itr)
{
int64_t specIndex=(*itr)-1;
progress(progressBegin+progressScaler*static_cast<double>(specIndex)/static_cast<double>(m_spec_list.size()),"Reading workspace data...");
loadBlock(data, errors, static_cast<int64_t>(1), nchannels, specIndex,wsIndex, local_workspace);
}
}
}
else
{
for( ; hist_index < read_stop; )
{
progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data...");
loadBlock(data, errors, blocksize, nchannels, hist_index,wsIndex, local_workspace);
}
int64_t finalblock = total_specs - read_stop;
if( finalblock > 0 )
{
loadBlock(data, errors, finalblock, nchannels, hist_index,wsIndex,local_workspace);
}
}
}
else
{
if(m_interval||m_list)
{
if(m_interval)
{
int64_t interval_specs=m_spec_max-m_spec_min;
fullblocks=(interval_specs)/blocksize;
read_stop = (fullblocks * blocksize)+m_spec_min-1;
if(interval_specs<blocksize)
{
blocksize=interval_specs;
read_stop=m_spec_max-1;
}
hist_index=m_spec_min-1;
for( ; hist_index < read_stop; )
{
progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data...");
loadBlock(data, errors, xbins, blocksize, nchannels, hist_index,wsIndex,local_workspace);
}
int64_t finalblock = m_spec_max-1 - read_stop;
if( finalblock > 0 )
{
loadBlock(data, errors, xbins, finalblock, nchannels, hist_index,wsIndex, local_workspace);
}
}
//
if(m_list)
{
std::vector<int64_t>::iterator itr=m_spec_list.begin();
for(;itr!=m_spec_list.end();++itr)
{
int64_t specIndex=(*itr)-1;
progress(progressBegin+progressScaler*static_cast<double>(specIndex)/static_cast<double>(read_stop),"Reading workspace data...");
loadBlock(data, errors, xbins, 1, nchannels, specIndex,wsIndex,local_workspace);
}
}
}
else
{
for( ; hist_index < read_stop; )
{
progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data...");
loadBlock(data, errors, xbins, blocksize, nchannels, hist_index,wsIndex,local_workspace);
}
int64_t finalblock = total_specs - read_stop;
if( finalblock > 0 )
{
loadBlock(data, errors, xbins, finalblock, nchannels, hist_index,wsIndex, local_workspace);
}
}
}
} //end of NOT an event -------------------------------
//Units
try
{
local_workspace->getAxis(0)->unit() = UnitFactory::Instance().create(unit1);
//If this doesn't throw then it is a numeric access so grab the data so we can set it later
axis2.load();
m_axis1vals = MantidVec(axis2(), axis2() + axis2.dim0());
}
catch( std::runtime_error & )
{
g_log.information() << "Axis 0 set to unitless quantity \"" << unit1 << "\"\n";
}
// Setting a unit onto a SpectraAxis makes no sense.
if ( unit2 == "TextAxis" )
{
Mantid::API::TextAxis* newAxis = new Mantid::API::TextAxis(nspectra);
local_workspace->replaceAxis(1, newAxis);
}
else if ( unit2 != "spectraNumber" )
{
try
{
Mantid::API::NumericAxis* newAxis = new Mantid::API::NumericAxis(nspectra);
local_workspace->replaceAxis(1, newAxis);
newAxis->unit() = UnitFactory::Instance().create(unit2);
}
catch( std::runtime_error & )
{
g_log.information() << "Axis 1 set to unitless quantity \"" << unit2 << "\"\n";
}
}
//Are we a distribution
std::string dist = xbins.attributes("distribution");
if( dist == "1" )
{
local_workspace->isDistribution(true);
}
else
{
local_workspace->isDistribution(false);
}
//Get information from all but data group
std::string parameterStr;
progress(progressStart+0.05*progressRange,"Reading the sample details...");
// Hop to the right point
cppFile->openPath(mtd_entry.path());
try
{
// This loads logs, sample, and instrument.
local_workspace->loadExperimentInfoNexus(cppFile, parameterStr);
}
catch (std::exception & e)
{
g_log.information("Error loading Instrument section of nxs file");
g_log.information(e.what());
}
// Now assign the spectra-detector map
readInstrumentGroup(mtd_entry, local_workspace);
// Parameter map parsing
progress(progressStart+0.11*progressRange,"Reading the parameter maps...");
local_workspace->readParameterMap(parameterStr);
if ( ! local_workspace->getAxis(1)->isSpectra() )
{ // If not a spectra axis, load the axis data into the workspace. (MW 25/11/10)
loadNonSpectraAxis(local_workspace, wksp_cls);
}
progress(progressStart+0.15*progressRange,"Reading the workspace history...");
try
{
readAlgorithmHistory(mtd_entry, local_workspace);
}
catch (std::out_of_range&)
{
g_log.warning() << "Error in the workspaces algorithm list, its processing history is incomplete\n";
}
progress(progressStart+0.2*progressRange,"Reading the workspace history...");
return boost::static_pointer_cast<API::Workspace>(local_workspace);
}
/** 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;
}
/**
* Load a given period into the workspace
* @param period :: The period number to load (starting from 1)
* @param entry :: The opened root entry node for accessing the monitor and data nodes
* @param local_workspace :: The workspace to place the data in
*/
void LoadISISNexus2::loadPeriodData(int64_t period, NXEntry & entry, DataObjects::Workspace2D_sptr local_workspace)
{
int64_t hist_index = 0;
int64_t period_index(period - 1);
int64_t first_monitor_spectrum = 0;
if( !m_monitors.empty() )
{
first_monitor_spectrum = m_monitors.begin()->first;
hist_index = first_monitor_spectrum - 1;
for(std::map<int64_t,std::string>::const_iterator it = m_monitors.begin();
it != m_monitors.end(); ++it)
{
NXData monitor = entry.openNXData(it->second);
NXInt mondata = monitor.openIntData();
m_progress->report("Loading monitor");
mondata.load(1,static_cast<int>(period-1)); // TODO this is just wrong
MantidVec& Y = local_workspace->dataY(hist_index);
Y.assign(mondata(),mondata() + m_numberOfChannels);
MantidVec& E = local_workspace->dataE(hist_index);
std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt);
local_workspace->getAxis(1)->spectraNo(hist_index) = static_cast<specid_t>(it->first);
NXFloat timeBins = monitor.openNXFloat("time_of_flight");
timeBins.load();
local_workspace->dataX(hist_index).assign(timeBins(),timeBins() + timeBins.dim0());
hist_index++;
}
if (first_monitor_spectrum > 1)
{
hist_index = 0;
}
}
if( m_have_detector )
{
NXData nxdata = entry.openNXData("detector_1");
NXDataSetTyped<int> data = nxdata.openIntData();
data.open();
//Start with thelist members that are lower than the required spectrum
const int * const spec_begin = m_spec.get();
std::vector<int64_t>::iterator min_end = m_spec_list.end();
if( !m_spec_list.empty() )
{
// If we have a list, by now it is ordered so first pull in the range below the starting block range
// Note the reverse iteration as we want the last one
if( m_range_supplied )
{
min_end = std::find_if(m_spec_list.begin(), m_spec_list.end(), std::bind2nd(std::greater<int>(), m_spec_min));
}
for( std::vector<int64_t>::iterator itr = m_spec_list.begin(); itr < min_end; ++itr )
{
// Load each
int64_t spectra_no = (*itr);
// For this to work correctly, we assume that the spectrum list increases monotonically
int64_t filestart = std::lower_bound(spec_begin,m_spec_end,spectra_no) - spec_begin;
m_progress->report("Loading data");
loadBlock(data, static_cast<int64_t>(1), period_index, filestart, hist_index, spectra_no, local_workspace);
}
}
if( m_range_supplied )
{
// When reading in blocks we need to be careful that the range is exactly divisible by the blocksize
// and if not have an extra read of the left overs
const int64_t blocksize = 8;
const int64_t rangesize = (m_spec_max - m_spec_min + 1) - m_monitors.size();
const int64_t fullblocks = rangesize / blocksize;
int64_t read_stop = 0;
int64_t spectra_no = m_spec_min;
if (first_monitor_spectrum == 1)
{// this if crudely checks whether the monitors are at the begining or end of the spectra
spectra_no += static_cast<int>(m_monitors.size());
}
// For this to work correctly, we assume that the spectrum list increases monotonically
int64_t filestart = std::lower_bound(spec_begin,m_spec_end,spectra_no) - spec_begin;
if( fullblocks > 0 )
{
read_stop = (fullblocks * blocksize);// + m_monitors.size(); //RNT: I think monitors are excluded from the data
//for( ; hist_index < read_stop; )
for(int64_t i = 0; i < fullblocks; ++i)
{
loadBlock(data, blocksize, period_index, filestart, hist_index, spectra_no, local_workspace);
filestart += blocksize;
}
}
int64_t finalblock = rangesize - (fullblocks * blocksize);
if( finalblock > 0 )
{
loadBlock(data, finalblock, period_index, filestart, hist_index, spectra_no, local_workspace);
}
}
//Load in the last of the list indices
for( std::vector<int64_t>::iterator itr = min_end; itr < m_spec_list.end(); ++itr )
{
// Load each
int64_t spectra_no = (*itr);
// For this to work correctly, we assume that the spectrum list increases monotonically
int64_t filestart = std::lower_bound(spec_begin,m_spec_end,spectra_no) - spec_begin;
loadBlock(data, 1, period_index, filestart, hist_index, spectra_no, local_workspace);
}
}
try
{
const std::string title = entry.getString("title");
local_workspace->setTitle(title);
// write the title into the log file (run object)
local_workspace->mutableRun().addProperty("run_title", title, true);
}
catch (std::runtime_error &)
{
g_log.debug() << "No title was found in the input file, " << getPropertyValue("Filename") << std::endl;
}
}
/**
* Load a given period into the workspace
* @param period :: The period number to load (starting from 1)
* @param entry :: The opened root entry node for accessing the monitor and data
* nodes
* @param local_workspace :: The workspace to place the data in
* @param update_spectra2det_mapping :: reset spectra-detector map to the one
* calculated earlier. (Warning! -- this map has to be calculated correctly!)
*/
void
LoadISISNexus2::loadPeriodData(int64_t period, NXEntry &entry,
DataObjects::Workspace2D_sptr &local_workspace,
bool update_spectra2det_mapping) {
int64_t hist_index = 0;
int64_t period_index(period - 1);
// int64_t first_monitor_spectrum = 0;
for (auto block = m_spectraBlocks.begin(); block != m_spectraBlocks.end();
++block) {
if (block->isMonitor) {
NXData monitor = entry.openNXData(block->monName);
NXInt mondata = monitor.openIntData();
m_progress->report("Loading monitor");
mondata.load(1, static_cast<int>(period - 1)); // TODO this is just wrong
MantidVec &Y = local_workspace->dataY(hist_index);
Y.assign(mondata(), mondata() + m_monBlockInfo.numberOfChannels);
MantidVec &E = local_workspace->dataE(hist_index);
std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt);
if (update_spectra2det_mapping) {
// local_workspace->getAxis(1)->setValue(hist_index,
// static_cast<specid_t>(it->first));
auto spec = local_workspace->getSpectrum(hist_index);
specid_t specID = m_specInd2specNum_map.at(hist_index);
spec->setDetectorIDs(
m_spec2det_map.getDetectorIDsForSpectrumNo(specID));
spec->setSpectrumNo(specID);
}
NXFloat timeBins = monitor.openNXFloat("time_of_flight");
timeBins.load();
local_workspace->dataX(hist_index)
.assign(timeBins(), timeBins() + timeBins.dim0());
hist_index++;
} else if (m_have_detector) {
NXData nxdata = entry.openNXData("detector_1");
NXDataSetTyped<int> data = nxdata.openIntData();
data.open();
// Start with the list members that are lower than the required spectrum
const int *const spec_begin = m_spec.get();
// When reading in blocks we need to be careful that the range is exactly
// divisible by the block-size
// and if not have an extra read of the left overs
const int64_t blocksize = 8;
const int64_t rangesize = block->last - block->first + 1;
const int64_t fullblocks = rangesize / blocksize;
int64_t spectra_no = block->first;
// For this to work correctly, we assume that the spectrum list increases
// monotonically
int64_t filestart =
std::lower_bound(spec_begin, m_spec_end, spectra_no) - spec_begin;
if (fullblocks > 0) {
for (int64_t i = 0; i < fullblocks; ++i) {
loadBlock(data, blocksize, period_index, filestart, hist_index,
spectra_no, local_workspace);
filestart += blocksize;
}
}
int64_t finalblock = rangesize - (fullblocks * blocksize);
if (finalblock > 0) {
loadBlock(data, finalblock, period_index, filestart, hist_index,
spectra_no, local_workspace);
}
}
}
try {
const std::string title = entry.getString("title");
local_workspace->setTitle(title);
// write the title into the log file (run object)
local_workspace->mutableRun().addProperty("run_title", title, true);
} catch (std::runtime_error &) {
g_log.debug() << "No title was found in the input file, "
<< getPropertyValue("Filename") << std::endl;
}
}