/** Load in a single spectrum taken from a NeXus file
* @param hist :: The workspace index
* @param i :: The spectrum index
* @param specNo :: The spectrum number
* @param nxload :: A reference to the MuonNeXusReader object
* @param lengthIn :: The number of elements in a spectrum
* @param localWorkspace :: A pointer to the workspace in which the data will be
* stored
*/
void LoadMuonNexus1::loadData(size_t hist, specid_t &i, specid_t specNo, MuonNexusReader &nxload,
const int64_t lengthIn,
DataObjects::Workspace2D_sptr localWorkspace) {
// Read in a spectrum
// Put it into a vector, discarding the 1st entry, which is rubbish
// But note that the last (overflow) bin is kept
// For Nexus, not sure if above is the case, hence give all data for now
MantidVec &Y = localWorkspace->dataY(hist);
Y.assign(nxload.counts + i * lengthIn,
nxload.counts + i * lengthIn + lengthIn);
// Create and fill another vector for the errors, containing sqrt(count)
MantidVec &E = localWorkspace->dataE(hist);
typedef double (*uf)(double);
uf dblSqrt = std::sqrt;
std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt);
// Populate the workspace. Loop starts from 1, hence i-1
// Create and fill another vector for the X axis
float *timeChannels = new float[lengthIn+1]();
nxload.getTimeChannels(timeChannels, static_cast<const int>(lengthIn+1));
// Put the read in array into a vector (inside a shared pointer)
boost::shared_ptr<MantidVec> timeChannelsVec(
new MantidVec(timeChannels, timeChannels + lengthIn+1));
localWorkspace->setX(hist, timeChannelsVec);
localWorkspace->getSpectrum(hist)->setSpectrumNo(specNo);
// Clean up
delete[] timeChannels;
}
/** Executes the algorithm. Reading in the file and creating and populating
* the output workspace
*
* @throw Exception::FileError If the RAW file cannot be found/opened
* @throw std::invalid_argument If the optional properties are set to invalid values
*/
void LoadRaw::exec()
{
// Retrieve the filename from the properties
m_filename = getPropertyValue("Filename");
LoadRawHelper *helper = new LoadRawHelper;
FILE* file = helper->openRawFile(m_filename);
ISISRAW iraw;
iraw.ioRAW(file, true);
std::string title(iraw.r_title, 80);
g_log.information("**** Run title: "+title+ "***");
// Read in the number of spectra in the RAW file
m_numberOfSpectra = iraw.t_nsp1;
// Read the number of periods in this file
m_numberOfPeriods = iraw.t_nper;
// Need to extract the user-defined output workspace name
Property *ws = getProperty("OutputWorkspace");
std::string localWSName = ws->value();
// Call private method to validate the optional parameters, if set
checkOptionalProperties();
// Read the number of time channels (i.e. bins) from the RAW file
const int channelsPerSpectrum = iraw.t_ntc1;
// Read in the time bin boundaries
const int lengthIn = channelsPerSpectrum + 1;
float* timeChannels = new float[lengthIn];
iraw.getTimeChannels(timeChannels, lengthIn);
// Put the read in array into a vector (inside a shared pointer)
boost::shared_ptr<MantidVec> timeChannelsVec
(new MantidVec(timeChannels, timeChannels + lengthIn));
// Create an array to hold the read-in data
int* spectrum = new int[lengthIn];
// Calculate the size of a workspace, given its number of periods & spectra to read
specid_t total_specs;
if( m_interval || m_list)
{
total_specs = static_cast<specid_t>(m_spec_list.size());
if (m_interval)
{
total_specs += (m_spec_max-m_spec_min+1);
m_spec_max += 1;
}
}
else
{
total_specs = m_numberOfSpectra;
// In this case want all the spectra, but zeroth spectrum is garbage so go from 1 to NSP1
m_spec_min = 1;
m_spec_max = m_numberOfSpectra + 1;
}
double histTotal = static_cast<double>(total_specs * m_numberOfPeriods);
int32_t histCurrent = -1;
// Create the 2D workspace for the output
DataObjects::Workspace2D_sptr localWorkspace = boost::dynamic_pointer_cast<DataObjects::Workspace2D>
(WorkspaceFactory::Instance().create("Workspace2D",total_specs,lengthIn,lengthIn-1));
localWorkspace->getAxis(0)->unit() = UnitFactory::Instance().create("TOF");
localWorkspace->setTitle(title);
// Run parameters
helper->loadRunParameters(localWorkspace, &iraw);
delete helper;
helper = NULL;
// Loop over the number of periods in the raw file, putting each period in a separate workspace
for (int period = 0; period < m_numberOfPeriods; ++period) {
if ( period > 0 ) localWorkspace = boost::dynamic_pointer_cast<DataObjects::Workspace2D>
(WorkspaceFactory::Instance().create(localWorkspace));
specid_t counter = 0;
for (specid_t i = m_spec_min; i < m_spec_max; ++i)
{
// Shift the histogram to read if we're not in the first period
int32_t histToRead = i + period*total_specs;
loadData(timeChannelsVec,counter,histToRead,iraw,lengthIn,spectrum,localWorkspace );
counter++;
if (++histCurrent % 100 == 0) progress(static_cast<double>(histCurrent)/histTotal);
interruption_point();
}
// Read in the spectra in the optional list parameter, if set
if (m_list)
{
for(size_t i=0; i < m_spec_list.size(); ++i)
{
loadData(timeChannelsVec,counter,m_spec_list[i],iraw,lengthIn,spectrum, localWorkspace );
counter++;
if (++histCurrent % 100 == 0) progress(static_cast<double>(histCurrent)/histTotal);
interruption_point();
}
}
// Just a sanity check
assert(counter == total_specs);
std::string outputWorkspace = "OutputWorkspace";
if (period == 0)
{
// Only run the Child Algorithms once
runLoadInstrument(localWorkspace );
runLoadMappingTable(localWorkspace );
runLoadLog(localWorkspace );
const int period_number = 1;
Property* log=createPeriodLog(period_number);
if(log)
{
localWorkspace->mutableRun().addLogData(log);
localWorkspace->mutableRun().addLogData(createCurrentPeriodLog(period_number));
}
// Set the total proton charge for this run
// (not sure how this works for multi_period files)
localWorkspace->mutableRun().setProtonCharge(iraw.rpb.r_gd_prtn_chrg);
}
else // We are working on a higher period of a multiperiod raw file
{
// Create a WorkspaceProperty for the new workspace of a higher period
// The workspace name given in the OutputWorkspace property has _periodNumber appended to it
// (for all but the first period, which has no suffix)
std::stringstream suffix;
suffix << (period+1);
outputWorkspace += suffix.str();
std::string WSName = localWSName + "_" + suffix.str();
declareProperty(new WorkspaceProperty<DataObjects::Workspace2D>(outputWorkspace,WSName,Direction::Output));
g_log.information() << "Workspace " << WSName << " created. \n";
}
if (localWorkspace)
localWorkspace->updateSpectraUsingMap();
// Assign the result to the output workspace property
setProperty(outputWorkspace,localWorkspace);
} // loop over periods
// Clean up
delete[] timeChannels;
delete[] spectrum;
}
/** Executes the algorithm. Reading in the file and creating and populating
* the output workspace
*
* @throw Exception::FileError If the RAW file cannot be found/opened
* @throw std::invalid_argument If the optional properties are set to invalid values
*/
void LoadRaw2::exec()
{
// Retrieve the filename from the properties
m_filename = getPropertyValue("Filename");
LoadRawHelper *helper = new LoadRawHelper;
FILE* file = helper->openRawFile(m_filename);
isisRaw->ioRAW(file, true);
std::string title(isisRaw->r_title, 80);
g_log.information("**** Run title: "+ title + "***");
// Read in the number of spectra in the RAW file
m_numberOfSpectra = isisRaw->t_nsp1;
// Read the number of periods in this file
m_numberOfPeriods = isisRaw->t_nper;
// Read the number of time channels (i.e. bins) from the RAW file
const int channelsPerSpectrum = isisRaw->t_ntc1;
// Read in the time bin boundaries
const int lengthIn = channelsPerSpectrum + 1;
// Call private method to validate the optional parameters, if set
checkOptionalProperties();
// Calculate the size of a workspace, given its number of periods & spectra to read
specid_t total_specs;
if( m_interval || m_list)
{
if (m_interval)
{
total_specs = (m_spec_max-m_spec_min+1);
m_spec_max += 1;
}
else
total_specs = 0;
if (m_list)
{
if (m_interval)
{
for(std::vector<specid_t>::iterator it=m_spec_list.begin();it!=m_spec_list.end();)
if (*it >= m_spec_min && *it <m_spec_max)
{
it = m_spec_list.erase(it);
}
else
++it;
}
if (m_spec_list.size() == 0) m_list = false;
total_specs += static_cast<specid_t>(m_spec_list.size());
}
}
else
{
total_specs = m_numberOfSpectra;
// In this case want all the spectra, but zeroth spectrum is garbage so go from 1 to NSP1
m_spec_min = 1;
m_spec_max = m_numberOfSpectra + 1;
}
// If there is not enough memory use ManagedRawFileWorkspace2D.
if ( ConfigService::Instance().getString("ManagedRawFileWorkspace.DoNotUse") != "1" &&
m_numberOfPeriods == 1 && MemoryManager::Instance().goForManagedWorkspace(total_specs,lengthIn,channelsPerSpectrum) &&
total_specs == m_numberOfSpectra)
{
const std::string cache_option = getPropertyValue("Cache");
size_t option = find(m_cache_options.begin(),m_cache_options.end(),cache_option) - m_cache_options.begin();
DataObjects::Workspace2D_sptr localWorkspace =
DataObjects::Workspace2D_sptr(
new ManagedRawFileWorkspace2D(m_filename, static_cast<int>(option)));
progress(0.,"Reading raw file...");
helper->loadRunParameters(localWorkspace, isisRaw.get());
runLoadInstrument(localWorkspace );
runLoadMappingTable(localWorkspace );
runLoadLog(localWorkspace );
const int period_number = 1;
Property* log=createPeriodLog(period_number);
if(log)
{
localWorkspace->mutableRun().addLogData(log);
localWorkspace->mutableRun().addLogData(createCurrentPeriodLog(period_number));
}
localWorkspace->mutableRun().setProtonCharge(isisRaw->rpb.r_gd_prtn_chrg);
for (int i = 0; i < m_numberOfSpectra; ++i)
localWorkspace->getAxis(1)->setValue(i, i+1);
localWorkspace->populateInstrumentParameters();
setProperty("OutputWorkspace",localWorkspace);
return;
}
float* timeChannels = new float[lengthIn];
isisRaw->getTimeChannels(timeChannels, lengthIn);
// Put the read in array into a vector (inside a shared pointer)
boost::shared_ptr<MantidVec> timeChannelsVec
(new MantidVec(timeChannels, timeChannels + lengthIn));
// Need to extract the user-defined output workspace name
Property *ws = getProperty("OutputWorkspace");
std::string localWSName = ws->value();
Progress pr(this,0.,1.,total_specs * m_numberOfPeriods);
// Create the 2D workspace for the output
DataObjects::Workspace2D_sptr localWorkspace = boost::dynamic_pointer_cast<DataObjects::Workspace2D>
(WorkspaceFactory::Instance().create("Workspace2D",total_specs,lengthIn,lengthIn-1));
localWorkspace->setTitle(title);
localWorkspace->getAxis(0)->unit() = UnitFactory::Instance().create("TOF");
// Run parameters
helper->loadRunParameters(localWorkspace, isisRaw.get());
delete helper;
helper = NULL;
// Loop over the number of periods in the raw file, putting each period in a separate workspace
for (int period = 0; period < m_numberOfPeriods; ++period) {
if ( period > 0 )
{
localWorkspace = boost::dynamic_pointer_cast<DataObjects::Workspace2D>
(WorkspaceFactory::Instance().create(localWorkspace));
}
isisRaw->skipData(file,period*(m_numberOfSpectra+1));
int counter = 0;
for (int i = 1; i <= m_numberOfSpectra; ++i)
{
int histToRead = i + period*(m_numberOfSpectra+1);
if ((i >= m_spec_min && i < m_spec_max) ||
(m_list && find(m_spec_list.begin(),m_spec_list.end(),i) != m_spec_list.end()))
{
isisRaw->readData(file,histToRead);
// Copy the data into the workspace vector, discarding the 1st entry, which is rubbish
// But note that the last (overflow) bin is kept
MantidVec& Y = localWorkspace->dataY(counter);
Y.assign(isisRaw->dat1 + 1, isisRaw->dat1 + lengthIn);
// Fill the vector for the errors, containing sqrt(count)
MantidVec& E = localWorkspace->dataE(counter);
std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt);
// Set the X vector pointer and spectrum number
localWorkspace->setX(counter, timeChannelsVec);
localWorkspace->getAxis(1)->setValue(counter, i);
// NOTE: Raw numbers go straight into the workspace
// - no account taken of bin widths/units etc.
++counter;
pr.report();
}
else
{
isisRaw->skipData(file,histToRead);
}
}
// Just a sanity check
assert(counter == total_specs);
std::string outputWorkspace = "OutputWorkspace";
if (period == 0)
{
// Only run the Child Algorithms once
runLoadInstrument(localWorkspace );
runLoadMappingTable(localWorkspace );
runLoadLog(localWorkspace );
const int period_number = period + 1;
Property* log=createPeriodLog(period_number);
if(log)
{
localWorkspace->mutableRun().addLogData(log);
localWorkspace->mutableRun().addLogData(createCurrentPeriodLog(period_number));
}
// Set the total proton charge for this run
// (not sure how this works for multi_period files)
localWorkspace->mutableRun().setProtonCharge(isisRaw->rpb.r_gd_prtn_chrg);
}
else // We are working on a higher period of a multiperiod raw file
{
// Create a WorkspaceProperty for the new workspace of a higher period
// The workspace name given in the OutputWorkspace property has _periodNumber appended to it
// (for all but the first period, which has no suffix)
std::stringstream suffix;
suffix << (period+1);
outputWorkspace += suffix.str();
std::string WSName = localWSName + "_" + suffix.str();
declareProperty(new WorkspaceProperty<DataObjects::Workspace2D>(outputWorkspace,WSName,Direction::Output));
g_log.information() << "Workspace " << WSName << " created. \n";
//remove previous period data
std::stringstream index;
index << (period);
std::string prevPeriod="PERIOD "+index.str();
localWorkspace->mutableRun().removeLogData(prevPeriod);
localWorkspace->mutableRun().removeLogData("current_period");
//add current period data
const int period_number = period + 1;
Property* log=createPeriodLog(period_number);
if(log)
{
localWorkspace->mutableRun().addLogData(log);
localWorkspace->mutableRun().addLogData(createCurrentPeriodLog(period_number));
}
}
// check if values stored in logfiles should be used to define parameters of the instrument
localWorkspace->populateInstrumentParameters();
// Assign the result to the output workspace property
setProperty(outputWorkspace,localWorkspace);
} // loop over periods
// Clean up
delete[] timeChannels;
//delete[] spectrum;
fclose(file);
}
