/** Load logs from Nexus file. Logs are expected to be in
* /raw_data_1/runlog group of the file. Call to this method must be done
* within /raw_data_1 group.
* @param ws :: The workspace to load the logs to.
* @param period :: The period of this workspace
*/
void LoadISISNexus2::loadLogs(DataObjects::Workspace2D_sptr ws, int period)
{
IAlgorithm_sptr alg = createSubAlgorithm("LoadNexusLogs", 0.0, 0.5);
alg->setPropertyValue("Filename", this->getProperty("Filename"));
alg->setProperty<MatrixWorkspace_sptr>("Workspace", ws);
try
{
alg->executeAsSubAlg();
}
catch(std::runtime_error&)
{
g_log.warning() << "Unable to load run logs. There will be no log "
<< "data associated with this workspace\n";
return;
}
ws->populateInstrumentParameters();
// If we loaded an icp_event log then create the necessary period logs
if( ws->run().hasProperty("icp_event") )
{
Kernel::Property *log = ws->run().getProperty("icp_event");
LogParser parser(log);
ws->mutableRun().addProperty(parser.createPeriodLog(period));
ws->mutableRun().addProperty(parser.createAllPeriodsLog());
}
}
/// Run the LoadLog Child Algorithm
void LoadMuonNexus1::runLoadLog(DataObjects::Workspace2D_sptr localWorkspace) {
IAlgorithm_sptr loadLog = createChildAlgorithm("LoadMuonLog");
// Pass through the same input filename
loadLog->setPropertyValue("Filename", m_filename);
// Set the workspace property to be the same one filled above
loadLog->setProperty<MatrixWorkspace_sptr>("Workspace", localWorkspace);
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try {
loadLog->execute();
} catch (std::runtime_error &) {
g_log.error("Unable to successfully run LoadMuonLog Child Algorithm");
} catch (std::logic_error &) {
g_log.error("Unable to successfully run LoadMuonLog Child Algorithm");
}
if (!loadLog->isExecuted())
g_log.error("Unable to successfully run LoadMuonLog Child Algorithm");
NXRoot root(m_filename);
// Get main field direction
std::string mainFieldDirection = "Longitudinal"; // default
try {
NXChar orientation = root.openNXChar("run/instrument/detector/orientation");
// some files have no data there
orientation.load();
if (orientation[0] == 't') {
auto p =
Kernel::make_unique<Kernel::TimeSeriesProperty<double>>("fromNexus");
std::string start_time = root.getString("run/start_time");
p->addValue(start_time, -90.0);
localWorkspace->mutableRun().addLogData(std::move(p));
mainFieldDirection = "Transverse";
}
} catch (...) {
// no data - assume main field was longitudinal
}
// set output property and add to workspace logs
auto &run = localWorkspace->mutableRun();
setProperty("MainFieldDirection", mainFieldDirection);
run.addProperty("main_field_direction", mainFieldDirection);
ISISRunLogs runLogs(run);
runLogs.addStatusLog(run);
}
/// Run the LoadLog Child Algorithm
void LoadMuonNexus1::runLoadLog(DataObjects::Workspace2D_sptr localWorkspace) {
IAlgorithm_sptr loadLog = createChildAlgorithm("LoadMuonLog");
// Pass through the same input filename
loadLog->setPropertyValue("Filename", m_filename);
// Set the workspace property to be the same one filled above
loadLog->setProperty<MatrixWorkspace_sptr>("Workspace", localWorkspace);
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try {
loadLog->execute();
} catch (std::runtime_error &) {
g_log.error("Unable to successfully run LoadLog Child Algorithm");
} catch (std::logic_error &) {
g_log.error("Unable to successfully run LoadLog Child Algorithm");
}
if (!loadLog->isExecuted())
g_log.error("Unable to successfully run LoadLog Child Algorithm");
NXRoot root(m_filename);
try {
NXChar orientation = root.openNXChar("run/instrument/detector/orientation");
// some files have no data there
orientation.load();
if (orientation[0] == 't') {
Kernel::TimeSeriesProperty<double> *p =
new Kernel::TimeSeriesProperty<double>("fromNexus");
std::string start_time = root.getString("run/start_time");
p->addValue(start_time, -90.0);
localWorkspace->mutableRun().addLogData(p);
setProperty("MainFieldDirection", "Transverse");
} else {
setProperty("MainFieldDirection", "Longitudinal");
}
} catch (...) {
setProperty("MainFieldDirection", "Longitudinal");
}
auto &run = localWorkspace->mutableRun();
int n = static_cast<int>(m_numberOfPeriods);
ISISRunLogs runLogs(run, n);
runLogs.addStatusLog(run);
}
/**
* Add the 'period i' log to a workspace.
* @param localWorkspace A workspace to add the log to.
* @param period A period for this workspace.
*/
void LoadMuonNexus1::addPeriodLog(DataObjects::Workspace2D_sptr localWorkspace,
int64_t period) {
auto &run = localWorkspace->mutableRun();
ISISRunLogs runLogs(run);
if (period == 0) {
runLogs.addPeriodLogs(1, run);
} else {
run.removeLogData("period 1");
runLogs.addPeriodLog(static_cast<int>(period) + 1, run);
}
}
/** Load logs from Nexus file. Logs are expected to be in
* /raw_data_1/runlog group of the file. Call to this method must be done
* within /raw_data_1 group.
* @param ws :: The workspace to load the logs to.
* @param entry :: Nexus entry
*/
void LoadISISNexus2::loadLogs(DataObjects::Workspace2D_sptr ws, NXEntry & entry)
{
IAlgorithm_sptr alg = createChildAlgorithm("LoadNexusLogs", 0.0, 0.5);
alg->setPropertyValue("Filename", this->getProperty("Filename"));
alg->setProperty<MatrixWorkspace_sptr>("Workspace", ws);
try
{
alg->executeAsChildAlg();
}
catch(std::runtime_error&)
{
g_log.warning() << "Unable to load run logs. There will be no log "
<< "data associated with this workspace\n";
return;
}
// For ISIS Nexus only, fabricate an addtional log containing an array of proton charge information from the periods group.
try
{
NXClass protonChargeClass = entry.openNXGroup("periods");
NXFloat periodsCharge = protonChargeClass.openNXFloat("proton_charge");
periodsCharge.load();
size_t nperiods = periodsCharge.dim0();
std::vector<double> chargesVector(nperiods);
std::copy(periodsCharge(), periodsCharge() + nperiods, chargesVector.begin());
ArrayProperty<double>* protonLogData = new ArrayProperty<double>("proton_charge_by_period", chargesVector);
ws->mutableRun().addProperty(protonLogData);
}
catch(std::runtime_error&)
{
this->g_log.debug("Cannot read periods information from the nexus file. This group may be absent.");
}
// Populate the instrument parameters.
ws->populateInstrumentParameters();
// Make log creator object and add the run status log
m_logCreator.reset(new ISISRunLogs(ws->run(), m_numberOfPeriods));
m_logCreator->addStatusLog(ws->mutableRun());
}
/** Log the run details from the file
* @param localWorkspace :: The workspace details to use
*/
void
LoadMuonNexus1::loadRunDetails(DataObjects::Workspace2D_sptr localWorkspace) {
API::Run &runDetails = localWorkspace->mutableRun();
runDetails.addProperty("run_title", localWorkspace->getTitle(), true);
int numSpectra = static_cast<int>(localWorkspace->getNumberHistograms());
runDetails.addProperty("nspectra", numSpectra);
NXRoot root(m_filename);
try {
std::string start_time = root.getString("run/start_time");
runDetails.addProperty("run_start", start_time);
} catch (std::runtime_error &) {
g_log.warning("run/start_time is not available, run_start log not added.");
}
try {
std::string stop_time = root.getString("run/stop_time");
runDetails.addProperty("run_end", stop_time);
} catch (std::runtime_error &) {
g_log.warning("run/stop_time is not available, run_end log not added.");
}
try {
std::string dur = root.getString("run/duration");
runDetails.addProperty("dur", dur);
runDetails.addProperty("durunits", 1); // 1 means second here
runDetails.addProperty("dur_secs", dur);
} catch (std::runtime_error &) {
g_log.warning("run/duration is not available, dur log not added.");
}
// Get sample parameters
NXEntry runSample = root.openEntry("run/sample");
if (runSample.containsDataSet("temperature")) {
float temperature = runSample.getFloat("temperature");
runDetails.addProperty("sample_temp", static_cast<double>(temperature));
}
if (runSample.containsDataSet("magnetic_field")) {
float magn_field = runSample.getFloat("magnetic_field");
runDetails.addProperty("sample_magn_field",
static_cast<double>(magn_field));
}
}
/** Log the run details from the file
* @param localWorkspace :: The workspace details to use
*/
void LoadMuonNexus2::loadRunDetails(
DataObjects::Workspace2D_sptr localWorkspace) {
API::Run &runDetails = localWorkspace->mutableRun();
runDetails.addProperty("run_title", localWorkspace->getTitle(), true);
int numSpectra = static_cast<int>(localWorkspace->getNumberHistograms());
runDetails.addProperty("nspectra", numSpectra);
m_filename = getPropertyValue("Filename");
NXRoot root(m_filename);
NXEntry entry = root.openEntry(m_entry_name);
std::string start_time = entry.getString("start_time");
runDetails.addProperty("run_start", start_time);
std::string stop_time = entry.getString("end_time");
runDetails.addProperty("run_end", stop_time);
if (entry.containsGroup("run")) {
NXClass runRun = entry.openNXGroup("run");
if (runRun.containsDataSet("good_total_frames")) {
int dum = runRun.getInt("good_total_frames");
runDetails.addProperty("goodfrm", dum);
}
if (runRun.containsDataSet("number_periods")) {
int dum = runRun.getInt("number_periods");
runDetails.addProperty("nperiods", dum);
}
}
{ // Duration taken to be stop_time minus stat_time
auto start = createFromSanitizedISO8601(start_time);
auto end = createFromSanitizedISO8601(stop_time);
double duration_in_secs = DateAndTime::secondsFromDuration(end - start);
runDetails.addProperty("dur_secs", duration_in_secs);
}
}
/**
* Load data about the run
* @param local_workspace :: The workspace to load the run information in to
* @param entry :: The Nexus entry
*/
void LoadISISNexus2::loadRunDetails(DataObjects::Workspace2D_sptr local_workspace, NXEntry & entry)
{
API::Run & runDetails = local_workspace->mutableRun();
// Charge is stored as a float
m_proton_charge = static_cast<double>(entry.getFloat("proton_charge"));
runDetails.setProtonCharge(m_proton_charge);
std::string run_num = boost::lexical_cast<std::string>(entry.getInt("run_number"));
runDetails.addProperty("run_number", run_num);
//
// Some details are only stored in the VMS compatability block so we'll pull everything from there
// for consistency
NXClass vms_compat = entry.openNXGroup("isis_vms_compat");
// Run header
NXChar char_data = vms_compat.openNXChar("HDR");
char_data.load();
runDetails.addProperty("run_header", std::string(char_data(),80));
// Data details on run not the workspace
runDetails.addProperty("nspectra", static_cast<int>(m_numberOfSpectraInFile));
runDetails.addProperty("nchannels", static_cast<int>(m_numberOfChannelsInFile));
runDetails.addProperty("nperiods", static_cast<int>(m_numberOfPeriodsInFile));
// RPB struct info
NXInt rpb_int = vms_compat.openNXInt("IRPB");
rpb_int.load();
runDetails.addProperty("dur", rpb_int[0]); // actual run duration
runDetails.addProperty("durunits", rpb_int[1]); // scaler for above (1=seconds)
runDetails.addProperty("dur_freq", rpb_int[2]); // testinterval for above (seconds)
runDetails.addProperty("dmp", rpb_int[3]); // dump interval
runDetails.addProperty("dmp_units", rpb_int[4]); // scaler for above
runDetails.addProperty("dmp_freq", rpb_int[5]); // interval for above
runDetails.addProperty("freq", rpb_int[6]); // 2**k where source frequency = 50 / 2**k
// Now double data
NXFloat rpb_dbl = vms_compat.openNXFloat("RRPB");
rpb_dbl.load();
runDetails.addProperty("gd_prtn_chrg", static_cast<double>(rpb_dbl[7])); // good proton charge (uA.hour)
runDetails.addProperty("tot_prtn_chrg", static_cast<double>(rpb_dbl[8])); // total proton charge (uA.hour)
runDetails.addProperty("goodfrm",rpb_int[9]); // good frames
runDetails.addProperty("rawfrm", rpb_int[10]); // raw frames
runDetails.addProperty("dur_wanted", rpb_int[11]); // requested run duration (units as for "duration" above)
runDetails.addProperty("dur_secs", rpb_int[12]); // actual run duration in seconds
runDetails.addProperty("mon_sum1", rpb_int[13]); // monitor sum 1
runDetails.addProperty("mon_sum2", rpb_int[14]); // monitor sum 2
runDetails.addProperty("mon_sum3",rpb_int[15]); // monitor sum 3
// End date and time is stored separately in ISO format in the "raw_data1/endtime" class
char_data = entry.openNXChar("end_time");
char_data.load();
std::string end_time_iso = std::string(char_data(), 19);
runDetails.addProperty("run_end", end_time_iso);
char_data = entry.openNXChar("start_time");
char_data.load();
std::string start_time_iso = std::string(char_data(), 19);
runDetails.addProperty("run_start", start_time_iso);
runDetails.addProperty("rb_proposal",rpb_int[21]); // RB (proposal) number
vms_compat.close();
}
/**
* 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;
}
}
/** 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;
}
/**
* Load data about the run
* @param local_workspace :: The workspace to load the run information in to
* @param entry :: The Nexus entry
*/
void
LoadISISNexus2::loadRunDetails(DataObjects::Workspace2D_sptr &local_workspace,
NXEntry &entry) {
API::Run &runDetails = local_workspace->mutableRun();
// Charge is stored as a float
m_proton_charge = static_cast<double>(entry.getFloat("proton_charge"));
runDetails.setProtonCharge(m_proton_charge);
std::string run_num =
boost::lexical_cast<std::string>(entry.getInt("run_number"));
runDetails.addProperty("run_number", run_num);
//
// Some details are only stored in the VMS comparability block so we'll pull
// everything from there
// for consistency
NXClass vms_compat = entry.openNXGroup("isis_vms_compat");
// Run header
NXChar char_data = vms_compat.openNXChar("HDR");
char_data.load();
// Space-separate the fields
char *nxsHdr = char_data();
char header[86] = {};
const size_t byte = sizeof(char);
const char fieldSep(' ');
size_t fieldWidths[7] = {3, 5, 20, 24, 12, 8, 8};
char *srcStart = nxsHdr;
char *destStart = header;
for (size_t i = 0; i < 7; ++i) {
size_t width = fieldWidths[i];
memcpy(destStart, srcStart, width * byte);
if (i < 6) // no space after last field
{
srcStart += width;
destStart += width;
memset(destStart, fieldSep, byte); // insert separator
destStart += 1;
}
}
runDetails.addProperty("run_header", std::string(header, header + 86));
// Data details on run not the workspace
runDetails.addProperty("nspectra",
static_cast<int>(m_loadBlockInfo.numberOfSpectra));
runDetails.addProperty("nchannels",
static_cast<int>(m_loadBlockInfo.numberOfChannels));
runDetails.addProperty("nperiods",
static_cast<int>(m_loadBlockInfo.numberOfPeriods));
// RPB struct info
NXInt rpb_int = vms_compat.openNXInt("IRPB");
rpb_int.load();
runDetails.addProperty("dur", rpb_int[0]); // actual run duration
runDetails.addProperty("durunits",
rpb_int[1]); // scaler for above (1=seconds)
runDetails.addProperty("dur_freq",
rpb_int[2]); // testinterval for above (seconds)
runDetails.addProperty("dmp", rpb_int[3]); // dump interval
runDetails.addProperty("dmp_units", rpb_int[4]); // scaler for above
runDetails.addProperty("dmp_freq", rpb_int[5]); // interval for above
runDetails.addProperty("freq",
rpb_int[6]); // 2**k where source frequency = 50 / 2**k
// Now double data
NXFloat rpb_dbl = vms_compat.openNXFloat("RRPB");
rpb_dbl.load();
runDetails.addProperty(
"gd_prtn_chrg",
static_cast<double>(rpb_dbl[7])); // good proton charge (uA.hour)
runDetails.addProperty(
"tot_prtn_chrg",
static_cast<double>(rpb_dbl[8])); // total proton charge (uA.hour)
runDetails.addProperty("goodfrm", rpb_int[9]); // good frames
runDetails.addProperty("rawfrm", rpb_int[10]); // raw frames
runDetails.addProperty(
"dur_wanted",
rpb_int[11]); // requested run duration (units as for "duration" above)
runDetails.addProperty("dur_secs",
rpb_int[12]); // actual run duration in seconds
runDetails.addProperty("mon_sum1", rpb_int[13]); // monitor sum 1
runDetails.addProperty("mon_sum2", rpb_int[14]); // monitor sum 2
runDetails.addProperty("mon_sum3", rpb_int[15]); // monitor sum 3
// End date and time is stored separately in ISO format in the
// "raw_data1/endtime" class
char_data = entry.openNXChar("end_time");
char_data.load();
std::string end_time_iso = std::string(char_data(), 19);
runDetails.addProperty("run_end", end_time_iso);
char_data = entry.openNXChar("start_time");
char_data.load();
std::string start_time_iso = std::string(char_data(), 19);
runDetails.addProperty("run_start", start_time_iso);
runDetails.addProperty("rb_proposal", rpb_int[21]); // RB (proposal) number
vms_compat.close();
}
/**
* Creates period log data in the workspace
* @param period :: period number
* @param local_workspace :: workspace to add period log data to.
*/
void LoadISISNexus2::createPeriodLogs(
int64_t period, DataObjects::Workspace2D_sptr &local_workspace) {
m_logCreator->addPeriodLogs(static_cast<int>(period),
local_workspace->mutableRun());
}
/**
* 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;
}
}
/// Overwrites Algorithm exec method
void LoadSpice2D::exec()
{
std::string fileName = getPropertyValue("Filename");
const double wavelength_input = getProperty("Wavelength");
const double wavelength_spread_input = getProperty("WavelengthSpread");
// Set up the DOM parser and parse xml file
DOMParser pParser;
Document* pDoc;
try
{
pDoc = pParser.parse(fileName);
} catch (...)
{
throw Kernel::Exception::FileError("Unable to parse File:", fileName);
}
// Get pointer to root element
Element* pRootElem = pDoc->documentElement();
if (!pRootElem->hasChildNodes())
{
throw Kernel::Exception::NotFoundError("No root element in Spice XML file", fileName);
}
// Read in start time
const std::string start_time = pRootElem->getAttribute("start_time");
Element* sasEntryElem = pRootElem->getChildElement("Header");
throwException(sasEntryElem, "Header", fileName);
// Read in scan title
Element* element = sasEntryElem->getChildElement("Scan_Title");
throwException(element, "Scan_Title", fileName);
std::string wsTitle = element->innerText();
// Read in instrument name
element = sasEntryElem->getChildElement("Instrument");
throwException(element, "Instrument", fileName);
std::string instrument = element->innerText();
// Read sample thickness
double sample_thickness = 0;
from_element<double>(sample_thickness, sasEntryElem, "Sample_Thickness", fileName);
double source_apert = 0.0;
from_element<double>(source_apert, sasEntryElem, "source_aperture_size", fileName);
double sample_apert = 0.0;
from_element<double>(sample_apert, sasEntryElem, "sample_aperture_size", fileName);
double source_distance = 0.0;
from_element<double>(source_distance, sasEntryElem, "source_distance", fileName);
// Read in wavelength and wavelength spread
double wavelength = 0;
double dwavelength = 0;
if ( isEmpty(wavelength_input) ) {
from_element<double>(wavelength, sasEntryElem, "wavelength", fileName);
from_element<double>(dwavelength, sasEntryElem, "wavelength_spread", fileName);
}
else
{
wavelength = wavelength_input;
dwavelength = wavelength_spread_input;
}
// Read in positions
sasEntryElem = pRootElem->getChildElement("Motor_Positions");
throwException(sasEntryElem, "Motor_Positions", fileName);
// Read in the number of guides
int nguides = 0;
from_element<int>(nguides, sasEntryElem, "nguides", fileName);
// Read in sample-detector distance in mm
double distance = 0;
from_element<double>(distance, sasEntryElem, "sample_det_dist", fileName);
distance *= 1000.0;
// Read in beam trap positions
double highest_trap = 0;
double trap_pos = 0;
from_element<double>(trap_pos, sasEntryElem, "trap_y_25mm", fileName);
double beam_trap_diam = 25.4;
from_element<double>(highest_trap, sasEntryElem, "trap_y_101mm", fileName);
if (trap_pos>highest_trap)
{
highest_trap = trap_pos;
beam_trap_diam = 101.6;
}
from_element<double>(trap_pos, sasEntryElem, "trap_y_50mm", fileName);
if (trap_pos>highest_trap)
{
highest_trap = trap_pos;
beam_trap_diam = 50.8;
}
from_element<double>(trap_pos, sasEntryElem, "trap_y_76mm", fileName);
if (trap_pos>highest_trap)
{
highest_trap = trap_pos;
beam_trap_diam = 76.2;
}
// Read in counters
sasEntryElem = pRootElem->getChildElement("Counters");
throwException(sasEntryElem, "Counters", fileName);
double countingTime = 0;
from_element<double>(countingTime, sasEntryElem, "time", fileName);
double monitorCounts = 0;
from_element<double>(monitorCounts, sasEntryElem, "monitor", fileName);
// Read in the data image
Element* sasDataElem = pRootElem->getChildElement("Data");
throwException(sasDataElem, "Data", fileName);
// Read in the data buffer
element = sasDataElem->getChildElement("Detector");
throwException(element, "Detector", fileName);
std::string data_str = element->innerText();
// Read in the detector dimensions from the Detector tag
int numberXPixels = 0;
int numberYPixels = 0;
std::string data_type = element->getAttribute("type");
boost::regex b_re_sig("INT\\d+\\[(\\d+),(\\d+)\\]");
if (boost::regex_match(data_type, b_re_sig))
{
boost::match_results<std::string::const_iterator> match;
boost::regex_search(data_type, match, b_re_sig);
// match[0] is the full string
Kernel::Strings::convert(match[1], numberXPixels);
Kernel::Strings::convert(match[2], numberYPixels);
}
if (numberXPixels==0 || numberYPixels==0)
g_log.notice() << "Could not read in the number of pixels!" << std::endl;
// We no longer read from the meta data because that data is wrong
//from_element<int>(numberXPixels, sasEntryElem, "Number_of_X_Pixels", fileName);
//from_element<int>(numberYPixels, sasEntryElem, "Number_of_Y_Pixels", fileName);
// Store sample-detector distance
declareProperty("SampleDetectorDistance", distance, Kernel::Direction::Output);
// Create the output workspace
// Number of bins: we use a single dummy TOF bin
int nBins = 1;
// Number of detectors: should be pulled from the geometry description. Use detector pixels for now.
// The number of spectram also includes the monitor and the timer.
int numSpectra = numberXPixels*numberYPixels + LoadSpice2D::nMonitors;
DataObjects::Workspace2D_sptr ws = boost::dynamic_pointer_cast<DataObjects::Workspace2D>(
API::WorkspaceFactory::Instance().create("Workspace2D", numSpectra, nBins+1, nBins));
ws->setTitle(wsTitle);
ws->getAxis(0)->unit() = Kernel::UnitFactory::Instance().create("Wavelength");
ws->setYUnit("");
API::Workspace_sptr workspace = boost::static_pointer_cast<API::Workspace>(ws);
setProperty("OutputWorkspace", workspace);
// Parse out each pixel. Pixels can be separated by white space, a tab, or an end-of-line character
Poco::StringTokenizer pixels(data_str, " \n\t", Poco::StringTokenizer::TOK_TRIM | Poco::StringTokenizer::TOK_IGNORE_EMPTY);
Poco::StringTokenizer::Iterator pixel = pixels.begin();
// Check that we don't keep within the size of the workspace
size_t pixelcount = pixels.count();
if( pixelcount != static_cast<size_t>(numberXPixels*numberYPixels) )
{
throw Kernel::Exception::FileError("Inconsistent data set: "
"There were more data pixels found than declared in the Spice XML meta-data.", fileName);
}
if( numSpectra == 0 )
{
throw Kernel::Exception::FileError("Empty data set: the data file has no pixel data.", fileName);
}
// Go through all detectors/channels
int ipixel = 0;
// Store monitor count
store_value(ws, ipixel++, monitorCounts, monitorCounts>0 ? sqrt(monitorCounts) : 0.0,
wavelength, dwavelength);
// Store counting time
store_value(ws, ipixel++, countingTime, 0.0, wavelength, dwavelength);
// Store detector pixels
while (pixel != pixels.end())
{
//int ix = ipixel%npixelsx;
//int iy = (int)ipixel/npixelsx;
// Get the count value and assign it to the right bin
double count = 0.0;
from_string<double>(count, *pixel, std::dec);
// Data uncertainties, computed according to the HFIR/IGOR reduction code
// The following is what I would suggest instead...
// error = count > 0 ? sqrt((double)count) : 0.0;
double error = sqrt( 0.5 + fabs( count - 0.5 ));
store_value(ws, ipixel, count, error, wavelength, dwavelength);
// Set the spectrum number
ws->getAxis(1)->setValue(ipixel, ipixel);
++pixel;
ipixel++;
}
// run load instrument
runLoadInstrument(instrument, ws);
runLoadMappingTable(ws, numberXPixels, numberYPixels);
// Set the run properties
ws->mutableRun().addProperty("sample-detector-distance", distance, "mm", true);
ws->mutableRun().addProperty("beam-trap-diameter", beam_trap_diam, "mm", true);
ws->mutableRun().addProperty("number-of-guides", nguides, true);
ws->mutableRun().addProperty("source-sample-distance", source_distance, "mm", true);
ws->mutableRun().addProperty("source-aperture-diameter", source_apert, "mm", true);
ws->mutableRun().addProperty("sample-aperture-diameter", sample_apert, "mm", true);
ws->mutableRun().addProperty("sample-thickness", sample_thickness, "cm", true);
ws->mutableRun().addProperty("wavelength", wavelength, "Angstrom", true);
ws->mutableRun().addProperty("wavelength-spread", dwavelength, "Angstrom", true);
ws->mutableRun().addProperty("timer", countingTime, "sec", true);
ws->mutableRun().addProperty("monitor", monitorCounts, "", true);
ws->mutableRun().addProperty("start_time", start_time, "", true);
ws->mutableRun().addProperty("run_start", start_time, "", true);
// Move the detector to the right position
API::IAlgorithm_sptr mover = createChildAlgorithm("MoveInstrumentComponent");
// Finding the name of the detector object.
std::string detID = ws->getInstrument()->getStringParameter("detector-name")[0];
g_log.information("Moving "+detID);
try
{
mover->setProperty<API::MatrixWorkspace_sptr> ("Workspace", ws);
mover->setProperty("ComponentName", detID);
mover->setProperty("Z", distance/1000.0);
mover->execute();
} catch (std::invalid_argument& e)
{
g_log.error("Invalid argument to MoveInstrumentComponent Child Algorithm");
g_log.error(e.what());
} catch (std::runtime_error& e)
{
g_log.error("Unable to successfully run MoveInstrumentComponent Child Algorithm");
g_log.error(e.what());
}
// Release the XML document memory
pDoc->release();
}
/** 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 LoadRawBin0::exec()
{
// Retrieve the filename from the properties
m_filename = getPropertyValue("Filename");
bool bLoadlogFiles = getProperty("LoadLogFiles");
//open the raw file
FILE* file=openRawFile(m_filename);
// Need to check that the file is not a text file as the ISISRAW routines don't deal with these very well, i.e
// reading continues until a bad_alloc is encountered.
if( isAscii(file) )
{
g_log.error() << "File \"" << m_filename << "\" is not a valid RAW file.\n";
throw std::invalid_argument("Incorrect file type encountered.");
}
std::string title;
readTitle(file,title);
readworkspaceParameters(m_numberOfSpectra,m_numberOfPeriods,m_lengthIn,m_noTimeRegimes);
///
setOptionalProperties();
// to validate the optional parameters, if set
checkOptionalProperties();
// Calculate the size of a workspace, given its number of periods & spectra to read
m_total_specs = calculateWorkspaceSize();
//no real X values for bin 0,so initialize this to zero
boost::shared_ptr<MantidVec> channelsVec(new MantidVec(1,0));
m_timeChannelsVec.push_back(channelsVec);
double histTotal = static_cast<double>(m_total_specs * m_numberOfPeriods);
int64_t histCurrent = -1;
// Create the 2D workspace for the output xlength and ylength is one
DataObjects::Workspace2D_sptr localWorkspace = createWorkspace(m_total_specs, 1,1,title);
Run& run = localWorkspace->mutableRun();
if (bLoadlogFiles)
{
runLoadLog(m_filename,localWorkspace, 0.0, 0.0);
const int period_number = 1;
createPeriodLogs(period_number, localWorkspace);
}
// Set the total proton charge for this run
setProtonCharge(run);
WorkspaceGroup_sptr ws_grp = createGroupWorkspace();
setWorkspaceProperty("OutputWorkspace", title, ws_grp, localWorkspace,m_numberOfPeriods, false);
// 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=createWorkspace(localWorkspace);
if (bLoadlogFiles)
{
//remove previous period data
std::stringstream prevPeriod;
prevPeriod << "PERIOD " << (period);
Run& runObj = localWorkspace->mutableRun();
runObj.removeLogData(prevPeriod.str());
runObj.removeLogData("current_period");
//add current period data
const int period_number = period + 1;
createPeriodLogs(period_number, localWorkspace);
}
}
skipData(file, period * (m_numberOfSpectra + 1));
int64_t wsIndex = 0;
for (specid_t i = 1; i <= m_numberOfSpectra; ++i)
{
int64_t 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()))
{
progress(m_prog, "Reading raw file data...");
//readData(file, histToRead);
//read spectrum
if (!readData(file, histToRead))
{
throw std::runtime_error("Error reading raw file");
}
int64_t binStart=0;
setWorkspaceData(localWorkspace, m_timeChannelsVec, wsIndex, i, m_noTimeRegimes,1,binStart);
++wsIndex;
if (m_numberOfPeriods == 1)
{
if (++histCurrent % 100 == 0)
{
m_prog = double(histCurrent) / histTotal;
}
interruption_point();
}
}
else
{
skipData(file, histToRead);
}
}
if(m_numberOfPeriods>1)
{
setWorkspaceProperty(localWorkspace, ws_grp, period, false);
// progress for workspace groups
m_prog = static_cast<double>(period) / static_cast<double>(m_numberOfPeriods - 1);
}
} // loop over periods
// Clean up
isisRaw.reset();
fclose(file);
}
/** 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);
}
void LoadMuonNexus1::addGoodFrames(DataObjects::Workspace2D_sptr localWorkspace,
int64_t period, int nperiods) {
// Get handle to nexus file
::NeXus::File handle(m_filename, NXACC_READ);
// For single-period datasets, read /run/instrument/beam/frames_good
if ( nperiods == 1 ) {
try {
handle.openPath("run/instrument/beam");
handle.openData("frames_good");
// read frames_period_daq
boost::scoped_array<int> dataVals(new int[1]);
handle.getData(dataVals.get());
auto &run = localWorkspace->mutableRun();
run.addProperty("goodfrm", dataVals[0]);
} catch (::NeXus::Exception &) {
g_log.warning("Could not read /run/instrument/beam/frames_good");
}
} else {
// For multi-period datasets, read entries in
// /run/instrument/beam/frames_period_daq
try {
handle.openPath("run/instrument/beam/");
handle.openData("frames_period_daq");
::NeXus::Info info = handle.getInfo();
// Check that frames_period_daq contains values for
// every period
if (period >= info.dims[0]) {
std::ostringstream error;
error << "goodfrm not found for period " << period;
throw std::runtime_error(error.str());
}
if (nperiods != info.dims[0]) {
std::ostringstream error;
error << "Inconsistent number of period entries found (";
error << info.dims[0];
error << "!=" << nperiods << ")";
throw std::runtime_error(error.str());
}
// read frames_period_daq
boost::scoped_array<int> dataVals(new int[info.dims[0]]);
handle.getData(dataVals.get());
auto &run = localWorkspace->mutableRun();
if (period == 0) {
// If this is the first period
// localWorkspace will not contain goodfrm
run.addProperty("goodfrm", dataVals[0]);
} else {
// If period > 0, we need to remove
// previous goodfrm log value
run.removeLogData("goodfrm");
run.addProperty("goodfrm", dataVals[period]);
}
} catch (::NeXus::Exception &) {
g_log.warning("Could not read /run/instrument/beam/frames_period_daq");
}
} // else
handle.close();
}