/**
* Load Data details (number of tubes, channels, etc)
*
* @param entry First entry of nexus file
*/
void LoadILLReflectometry::loadDataDetails(NeXus::NXEntry &entry) {
// PSD data D17 256 x 1 x 1000
// PSD data Figaro 1 x 256 x 1000
if (m_acqMode) {
NXFloat timeOfFlight = entry.openNXFloat("instrument/PSD/time_of_flight");
timeOfFlight.load();
m_channelWidth = static_cast<double>(timeOfFlight[0]);
m_numberOfChannels = size_t(timeOfFlight[1]);
m_tofDelay = timeOfFlight[2];
if (m_instrument == Supported::Figaro) {
NXFloat eDelay = entry.openNXFloat("instrument/Theta/edelay_delay");
eDelay.load();
m_tofDelay += static_cast<double>(eDelay[0]);
}
} else { // monochromatic mode
m_numberOfChannels = 1;
}
NXInt nChannels = entry.openNXInt("instrument/PSD/detsize");
nChannels.load();
m_numberOfHistograms = nChannels[0];
g_log.debug()
<< "Please note that ILL reflectometry instruments have "
"several tubes, after integration one "
"tube remains in the Nexus file.\n Number of tubes (banks): 1\n";
g_log.debug() << "Number of pixels per tube (number of detectors and number "
"of histograms): " << m_numberOfHistograms << '\n';
g_log.debug() << "Number of time channels: " << m_numberOfChannels << '\n';
g_log.debug() << "Channel width: " << m_channelWidth << " 1e-6 sec\n";
g_log.debug() << "TOF delay: " << m_tofDelay << '\n';
}
/**
* Load monitors data found in nexus file
*
* @param entry :: The Nexus entry
*
*/
std::vector<std::vector<int>>
LoadILLReflectometry::loadMonitors(NeXus::NXEntry &entry) {
// read in the data
g_log.debug("Fetching monitor data...");
NXData dataGroup = entry.openNXData("monitor1/data");
NXInt data = dataGroup.openIntData();
// load the counts from the file into memory
data.load();
std::vector<std::vector<int>> monitors(
1); // vector of monitors with one entry
std::vector<int> monitor1(data(), data() + data.size());
monitors[0].swap(monitor1);
// There is two monitors in data file, but the second one seems to be always 0
dataGroup = entry.openNXData("monitor2/data");
data = dataGroup.openIntData();
data.load();
std::vector<int> monitor2(data(), data() + data.size());
monitors.push_back(monitor2);
return monitors;
}
void LoadLLB::loadTimeDetails(NeXus::NXEntry &entry) {
m_wavelength = entry.getFloat("nxbeam/incident_wavelength");
// Apparently this is in the wrong units
// http://iramis.cea.fr/Phocea/file.php?class=page&reload=1227895533&file=21/How_to_install_and_use_the_Fitmib_suite_v28112008.pdf
m_channelWidth = entry.getInt("nxmonitor/channel_width") * 0.1;
g_log.debug("Nexus Data:");
g_log.debug() << " ChannelWidth: " << m_channelWidth << '\n';
g_log.debug() << " Wavelength: " << m_wavelength << '\n';
}
/**
* Init names of sample logs based on instrument specific NeXus file
* entries
*
* @param entry :: the NeXus file entry
*/
void LoadILLReflectometry::initNames(NeXus::NXEntry &entry) {
std::string instrumentNamePath = m_loader.findInstrumentNexusPath(entry);
std::string instrumentName =
entry.getString(instrumentNamePath.append("/name"));
if (instrumentName.empty())
throw std::runtime_error(
"Cannot set the instrument name from the Nexus file!");
boost::to_lower(instrumentName);
if (instrumentName == "d17") {
m_instrument = Supported::D17;
} else if (instrumentName == "figaro") {
m_instrument = Supported::Figaro;
} else {
std::ostringstream str;
str << "Unsupported instrument: " << instrumentName << '.';
throw std::runtime_error(str.str());
}
g_log.debug() << "Instrument name: " << instrumentName << '\n';
if (m_instrument == Supported::D17) {
m_detectorDistanceName = "det";
m_detectorAngleName = "dan.value";
m_sampleAngleName = "san.value";
m_offsetFrom = "VirtualChopper";
m_offsetName = "open_offset";
m_chopper1Name = "Chopper1";
m_chopper2Name = "Chopper2";
} else if (m_instrument == Supported::Figaro) {
// For Figaro, the DTR field contains the sample-to-detector distance
// when the detector is at the horizontal position (angle = 0).
m_detectorDistanceName = "DTR";
m_detectorAngleName = "VirtualAxis.DAN_actual_angle";
m_sampleAngleName = "CollAngle.actual_coll_angle";
m_offsetFrom = "CollAngle";
m_offsetName = "openOffset";
// Figaro: find out which of the four choppers are used
NXFloat firstChopper =
entry.openNXFloat("instrument/ChopperSetting/firstChopper");
firstChopper.load();
NXFloat secondChopper =
entry.openNXFloat("instrument/ChopperSetting/secondChopper");
secondChopper.load();
m_chopper1Name = "CH" + std::to_string(int(firstChopper[0]));
m_chopper2Name = "CH" + std::to_string(int(secondChopper[0]));
}
// get acquisition mode
NXInt acqMode = entry.openNXInt("acquisition_mode");
acqMode.load();
m_acqMode = acqMode[0];
m_acqMode ? g_log.debug("TOF mode") : g_log.debug("Monochromatic Mode");
}
/**
* Load Data details (number of tubes, channels, etc)
* @param entry First entry of nexus file
*/
void LoadILLIndirect::loadDataDetails(NeXus::NXEntry &entry) {
// read in the data
NXData dataGroup = entry.openNXData("data");
NXInt data = dataGroup.openIntData();
m_numberOfTubes = static_cast<size_t>(data.dim0());
m_numberOfPixelsPerTube = static_cast<size_t>(data.dim1());
m_numberOfChannels = static_cast<size_t>(data.dim2());
NXData dataSDGroup = entry.openNXData("dataSD");
NXInt dataSD = dataSDGroup.openIntData();
m_numberOfSimpleDetectors = static_cast<size_t>(dataSD.dim0());
}
size_t
LoadILLSANS::loadDataIntoWorkspaceFromMonitors(NeXus::NXEntry &firstEntry,
size_t firstIndex) {
// let's find the monitors
// For D33 should be monitor1 and monitor2
for (std::vector<NXClassInfo>::const_iterator it =
firstEntry.groups().begin();
it != firstEntry.groups().end(); ++it) {
if (it->nxclass == "NXmonitor") {
NXData dataGroup = firstEntry.openNXData(it->nxname);
NXInt data = dataGroup.openIntData();
data.load();
g_log.debug() << "Monitor: " << it->nxname << " dims = " << data.dim0()
<< "x" << data.dim1() << "x" << data.dim2() << '\n';
const size_t vectorSize = data.dim2() + 1;
std::vector<double> positionsBinning;
positionsBinning.reserve(vectorSize);
for (size_t i = 0; i < vectorSize; i++)
positionsBinning.push_back(static_cast<double>(i));
// Assign X
m_localWorkspace->dataX(firstIndex)
.assign(positionsBinning.begin(), positionsBinning.end());
// Assign Y
m_localWorkspace->dataY(firstIndex).assign(data(), data() + data.dim2());
// Assign Error
MantidVec &E = m_localWorkspace->dataE(firstIndex);
std::transform(data(), data() + data.dim2(), E.begin(),
LoadHelper::calculateStandardError);
// Add average monitor counts to a property:
double averageMonitorCounts =
std::accumulate(data(), data() + data.dim2(), 0) /
static_cast<double>(data.dim2());
// make sure the monitor has values!
if (averageMonitorCounts > 0) {
API::Run &runDetails = m_localWorkspace->mutableRun();
runDetails.addProperty("monitor", averageMonitorCounts, true);
}
firstIndex++;
}
}
return firstIndex;
}
/**
* Load data from nexus file
*
* @param entry :: The Nexus file entry
* @param monitorsData :: Monitors data already loaded
* @param xVals :: X values
*/
void LoadILLReflectometry::loadData(
NeXus::NXEntry &entry, const std::vector<std::vector<int>> &monitorsData,
const std::vector<double> &xVals) {
g_log.debug("Loading data...");
NXData dataGroup = entry.openNXData("data");
NXInt data = dataGroup.openIntData();
// load the counts from the file into memory
data.load();
const size_t nb_monitors = monitorsData.size();
Progress progress(this, 0, 1, m_numberOfHistograms + nb_monitors);
// write monitors
if (!xVals.empty()) {
HistogramData::BinEdges binEdges(xVals);
// write data
for (size_t j = 0; j < m_numberOfHistograms; ++j) {
const int *data_p = &data(0, static_cast<int>(j), 0);
const HistogramData::Counts counts(data_p, data_p + m_numberOfChannels);
m_localWorkspace->setHistogram(j, binEdges, std::move(counts));
progress.report();
for (size_t im = 0; im < nb_monitors; ++im) {
const int *monitor_p = monitorsData[im].data();
const HistogramData::Counts counts(monitor_p,
monitor_p + m_numberOfChannels);
m_localWorkspace->setHistogram(im + m_numberOfHistograms, binEdges,
std::move(counts));
progress.report();
}
}
} else
g_log.debug("Vector of x values is empty");
}
void LoadSINQFocus::loadDataIntoTheWorkSpace(NeXus::NXEntry& entry) {
// read in the data
NXData dataGroup = entry.openNXData("merged");
NXInt data = dataGroup.openIntData();
data.load();
std::vector<double> timeBinning = m_loader.getTimeBinningFromNexusPath(entry, "merged/time_binning");
m_localWorkspace->dataX(0).assign(timeBinning.begin(),timeBinning.end());
Progress progress(this, 0, 1, m_numberOfTubes * m_numberOfPixelsPerTube);
size_t spec = 0;
for (size_t i = 0; i < m_numberOfTubes; ++i) {
for (size_t j = 0; j < m_numberOfPixelsPerTube; ++j) {
if (spec > 0) {
// just copy the time binning axis to every spectra
m_localWorkspace->dataX(spec) = m_localWorkspace->readX(0);
}
// Assign Y
int* data_p = &data(static_cast<int>(i), static_cast<int>(j));
m_localWorkspace->dataY(spec).assign(data_p,
data_p + m_numberOfChannels);
// Assign Error
MantidVec& E = m_localWorkspace->dataE(spec);
std::transform(data_p, data_p + m_numberOfChannels, E.begin(),
LoadSINQFocus::calculateError);
++spec;
progress.report();
}
}
g_log.debug() << "Data loading into WS done...." << std::endl;
}
void LoadSINQFocus::initWorkSpace(NeXus::NXEntry& entry) {
// read in the data
NXData dataGroup = entry.openNXData("merged");
NXInt data = dataGroup.openIntData();
m_numberOfTubes = static_cast<size_t>(data.dim0());
m_numberOfPixelsPerTube = 1;
m_numberOfChannels = static_cast<size_t>(data.dim1());
// dim0 * m_numberOfPixelsPerTube is the total number of detectors
m_numberOfHistograms = m_numberOfTubes * m_numberOfPixelsPerTube;
g_log.debug() << "NumberOfTubes: " << m_numberOfTubes << std::endl;
g_log.debug() << "NumberOfPixelsPerTube: " << m_numberOfPixelsPerTube
<< std::endl;
g_log.debug() << "NumberOfChannels: " << m_numberOfChannels << std::endl;
// Now create the output workspace
// Might need to get this value from the number of monitors in the Nexus file
// params:
// workspace type,
// total number of spectra + (number of monitors = 0),
// bin boundaries = m_numberOfChannels + 1
// Z/time dimension
m_localWorkspace = WorkspaceFactory::Instance().create("Workspace2D",
m_numberOfHistograms, m_numberOfChannels + 1, m_numberOfChannels);
m_localWorkspace->getAxis(0)->unit() = UnitFactory::Instance().create(
"TOF");
m_localWorkspace->setYUnitLabel("Counts");
}
/**
* Load single monitor
*
* @param entry :: The Nexus entry
* @param monitor_data :: A std::string containing the Nexus path to the monitor
*data
* @return monitor :: A std::vector containing monitor values
*/
std::vector<int>
LoadILLReflectometry::loadSingleMonitor(NeXus::NXEntry &entry,
const std::string &monitor_data) {
NXData dataGroup = entry.openNXData(monitor_data);
NXInt data = dataGroup.openIntData();
// load counts
data.load();
return std::vector<int>(data(), data() + data.size());
}
/**
* Load monitors data found in nexus file
*
* @param entry :: The Nexus entry
*
*/
std::vector<std::vector<int>>
LoadILLIndirect::loadMonitors(NeXus::NXEntry &entry) {
// read in the data
g_log.debug("Fetching monitor data...");
NXData dataGroup = entry.openNXData("monitor/data");
NXInt data = dataGroup.openIntData();
// load the counts from the file into memory
data.load();
// For the moment, we are aware of only one monitor entry, but we keep the
// generalized case of n monitors
std::vector<std::vector<int>> monitors(1);
std::vector<int> monitor(data(), data() + data.size());
monitors[0].swap(monitor);
return monitors;
}
void LoadLLB::loadDataIntoTheWorkSpace(NeXus::NXEntry &entry) {
// read in the data
NXData dataGroup = entry.openNXData("nxdata");
NXFloat data = dataGroup.openFloatData();
data.load();
// EPP
int calculatedDetectorElasticPeakPosition =
getDetectorElasticPeakPosition(data);
std::vector<double> timeBinning =
getTimeBinning(calculatedDetectorElasticPeakPosition, m_channelWidth);
// Assign time bin to first X entry
m_localWorkspace->dataX(0).assign(timeBinning.begin(), timeBinning.end());
Progress progress(this, 0, 1, m_numberOfTubes * m_numberOfPixelsPerTube);
size_t spec = 0;
for (size_t i = 0; i < m_numberOfTubes; ++i) {
for (size_t j = 0; j < m_numberOfPixelsPerTube; ++j) {
if (spec > 0) {
// just copy the time binning axis to every spectra
m_localWorkspace->dataX(spec) = m_localWorkspace->readX(0);
}
// Assign Y
float *data_p = &data(static_cast<int>(i), static_cast<int>(j));
m_localWorkspace->dataY(spec).assign(data_p, data_p + m_numberOfChannels);
// Assign Error
MantidVec &E = m_localWorkspace->dataE(spec);
std::transform(data_p, data_p + m_numberOfChannels, E.begin(),
LoadLLB::calculateError);
++spec;
progress.report();
}
}
g_log.debug() << "Data loading inti WS done....\n";
}
/**
* Load data found in nexus file
*
* @param entry :: The Nexus entry
* @param monitorsData :: Monitors data already loaded
*
*/
void LoadILLReflectometry::loadDataIntoTheWorkSpace(
NeXus::NXEntry &entry, std::vector<std::vector<int>> monitorsData) {
m_wavelength = entry.getFloat("wavelength");
double ei = m_loader.calculateEnergy(m_wavelength);
m_localWorkspace->mutableRun().addProperty<double>("Ei", ei,
true); // overwrite
// read in the data
NXData dataGroup = entry.openNXData("data");
NXInt data = dataGroup.openIntData();
// load the counts from the file into memory
data.load();
// Assign calculated bins to first X axis
//// m_localWorkspace->dataX(0).assign(detectorTofBins.begin(),
/// detectorTofBins.end());
size_t spec = 0;
size_t nb_monitors = monitorsData.size();
Progress progress(this, 0, 1,
m_numberOfTubes * m_numberOfPixelsPerTube + nb_monitors);
// Assign tof values to first X axis
// 1) Get some parameters from nexus file and properties
// Note : This should be changed following future D17/ILL nexus file
// improvement.
const std::string propTOF0 = "monitor1.time_of_flight_0";
auto tof_channel_width_prop = dynamic_cast<PropertyWithValue<double> *>(
m_localWorkspace->run().getProperty(propTOF0));
if (!tof_channel_width_prop)
throw std::runtime_error("Could not cast (interpret) the property " +
propTOF0 + " (channel width) as a floating point "
"value.");
m_channelWidth = *tof_channel_width_prop; /* PAR1[95] */
const std::string propTOF2 = "monitor1.time_of_flight_2";
auto tof_delay_prop = dynamic_cast<PropertyWithValue<double> *>(
m_localWorkspace->run().getProperty(propTOF2));
if (!tof_delay_prop)
throw std::runtime_error("Could not cast (interpret) the property " +
propTOF2 +
" (ToF delay) as a floating point value.");
double tof_delay = *tof_delay_prop; /* PAR1[96] */
double POFF = entry.getFloat("instrument/VirtualChopper/poff"); /* par1[54] */
double open_offset =
entry.getFloat("instrument/VirtualChopper/open_offset"); /* par1[56] */
double mean_chop_1_phase = 0.0;
double mean_chop_2_phase = 0.0;
// [30/09/14] Test on availability of VirtualChopper data
double chop1_speed = entry.getFloat(
"instrument/VirtualChopper/chopper1_speed_average"); /* PAR2[109] */
if (chop1_speed != 0.0) {
// Virtual Chopper entries are valid
// double mean_chop_1_phase =
// entry.getFloat("instrument/VirtualChopper/chopper1_phase_average"); /*
// PAR2[110] */
// this entry seems to be wrong for now, we use the old one instead [YR
// 5/06/2014]
mean_chop_1_phase = entry.getFloat("instrument/Chopper1/phase");
mean_chop_2_phase = entry.getFloat(
"instrument/VirtualChopper/chopper2_phase_average"); /* PAR2[114] */
} else {
// Use Chopper values instead
chop1_speed =
entry.getFloat("instrument/Chopper1/rotation_speed"); /* PAR2[109] */
mean_chop_1_phase = entry.getFloat("instrument/Chopper1/phase");
mean_chop_2_phase = entry.getFloat("instrument/Chopper2/phase");
}
g_log.debug() << "m_numberOfChannels: " << m_numberOfChannels << std::endl;
g_log.debug() << "m_channelWidth: " << m_channelWidth << std::endl;
g_log.debug() << "tof_delay: " << tof_delay << std::endl;
g_log.debug() << "POFF: " << POFF << std::endl;
g_log.debug() << "open_offset: " << open_offset << std::endl;
g_log.debug() << "mean_chop_2_phase: " << mean_chop_2_phase << std::endl;
g_log.debug() << "mean_chop_1_phase: " << mean_chop_1_phase << std::endl;
g_log.debug() << "chop1_speed: " << chop1_speed << std::endl;
double t_TOF2 = 0.0;
if (chop1_speed == 0.0) {
g_log.debug() << "Warning: chop1_speed is null." << std::endl;
// stay with t_TOF2 to O.0
} else {
// Thanks to Miguel Gonzales/ILL for this TOF formula
t_TOF2 = -1.e6 * 60.0 * (POFF - 45.0 + mean_chop_2_phase -
mean_chop_1_phase + open_offset) /
(2.0 * 360 * chop1_speed);
}
g_log.debug() << "t_TOF2: " << t_TOF2 << std::endl;
// 2) Compute tof values
for (size_t timechannelnumber = 0; timechannelnumber <= m_numberOfChannels;
++timechannelnumber) {
double t_TOF1 =
(static_cast<int>(timechannelnumber) + 0.5) * m_channelWidth +
tof_delay;
m_localWorkspace->dataX(0)[timechannelnumber] = t_TOF1 + t_TOF2;
}
// Load monitors
for (size_t im = 0; im < nb_monitors; im++) {
if (im > 0) {
m_localWorkspace->dataX(im) = m_localWorkspace->readX(0);
}
// Assign Y
int *monitor_p = monitorsData[im].data();
m_localWorkspace->dataY(im)
.assign(monitor_p, monitor_p + m_numberOfChannels);
progress.report();
}
// Then Tubes
for (size_t i = 0; i < m_numberOfTubes; ++i) {
for (size_t j = 0; j < m_numberOfPixelsPerTube; ++j) {
// just copy the time binning axis to every spectra
m_localWorkspace->dataX(spec + nb_monitors) = m_localWorkspace->readX(0);
//// Assign Y
int *data_p = &data(static_cast<int>(i), static_cast<int>(j), 0);
m_localWorkspace->dataY(spec + nb_monitors)
.assign(data_p, data_p + m_numberOfChannels);
// Assign Error
MantidVec &E = m_localWorkspace->dataE(spec + nb_monitors);
std::transform(data_p, data_p + m_numberOfChannels, E.begin(),
LoadHelper::calculateStandardError);
++spec;
progress.report();
}
} // for m_numberOfTubes
} // LoadILLIndirect::loadDataIntoTheWorkSpace
/*
* Loads metadata present in the nexus file
*/
void LoadILLSANS::loadMetaData(const NeXus::NXEntry &entry,
const std::string &instrumentNamePath) {
g_log.debug("Loading metadata...");
API::Run &runDetails = m_localWorkspace->mutableRun();
int runNum = entry.getInt("run_number");
std::string run_num = std::to_string(runNum);
runDetails.addProperty("run_number", run_num);
if (entry.getFloat("mode") == 0.0) { // Not TOF
runDetails.addProperty<std::string>("tof_mode", "Non TOF");
} else {
runDetails.addProperty<std::string>("tof_mode", "TOF");
}
std::string desc =
m_loader.getStringFromNexusPath(entry, "sample_description");
runDetails.addProperty("sample_description", desc);
std::string start_time = entry.getString("start_time");
start_time = m_loader.dateTimeInIsoFormat(start_time);
runDetails.addProperty("run_start", start_time);
std::string end_time = entry.getString("end_time");
end_time = m_loader.dateTimeInIsoFormat(end_time);
runDetails.addProperty("run_end", end_time);
double duration = entry.getFloat("duration");
runDetails.addProperty("timer", duration);
double wavelength =
entry.getFloat(instrumentNamePath + "/selector/wavelength");
g_log.debug() << "Wavelength found in the nexus file: " << wavelength << '\n';
if (wavelength <= 0) {
g_log.debug() << "Mode = " << entry.getFloat("mode") << '\n';
g_log.information("The wavelength present in the NeXus file <= 0.");
if (entry.getFloat("mode") == 0.0) { // Not TOF
throw std::runtime_error("Working in Non TOF mode and the wavelength in "
"the file is <=0 !!! Check with the instrument "
"scientist!");
}
} else {
double wavelengthRes =
entry.getFloat(instrumentNamePath + "/selector/wavelength_res");
runDetails.addProperty<double>("wavelength", wavelength);
double ei = m_loader.calculateEnergy(wavelength);
runDetails.addProperty<double>("Ei", ei, true);
// wavelength
m_defaultBinning[0] = wavelength - wavelengthRes * wavelength * 0.01 / 2;
m_defaultBinning[1] = wavelength + wavelengthRes * wavelength * 0.01 / 2;
}
// Put the detector distances:
// std::string detectorPath(instrumentNamePath + "/detector");
// // Just for Sample - RearDetector
// double sampleDetectorDistance =
// m_loader.getDoubleFromNexusPath(entry,detectorPath + "/det2_calc");
// runDetails.addProperty("sample_detector_distance",
// sampleDetectorDistance);
}
void LoadILLSANS::initWorkSpace(NeXus::NXEntry &firstEntry,
const std::string &instrumentPath) {
g_log.debug("Fetching data...");
NXData dataGroup1 = firstEntry.openNXData("data1");
NXInt dataRear = dataGroup1.openIntData();
dataRear.load();
NXData dataGroup2 = firstEntry.openNXData("data2");
NXInt dataRight = dataGroup2.openIntData();
dataRight.load();
NXData dataGroup3 = firstEntry.openNXData("data3");
NXInt dataLeft = dataGroup3.openIntData();
dataLeft.load();
NXData dataGroup4 = firstEntry.openNXData("data4");
NXInt dataDown = dataGroup4.openIntData();
dataDown.load();
NXData dataGroup5 = firstEntry.openNXData("data5");
NXInt dataUp = dataGroup5.openIntData();
dataUp.load();
g_log.debug("Checking channel numbers...");
// check number of channels
if (dataRear.dim2() != dataRight.dim2() &&
dataRight.dim2() != dataLeft.dim2() &&
dataLeft.dim2() != dataDown.dim2() && dataDown.dim2() != dataUp.dim2()) {
throw std::runtime_error(
"The time bins have not the same dimension for all the 5 detectors!");
}
int numberOfHistograms =
dataRear.dim0() * dataRear.dim1() + dataRight.dim0() * dataRight.dim1() +
dataLeft.dim0() * dataLeft.dim1() + dataDown.dim0() * dataDown.dim1() +
dataUp.dim0() * dataUp.dim1();
g_log.debug("Creating empty workspace...");
// TODO : Must put this 2 somewhere else: number of monitors!
createEmptyWorkspace(numberOfHistograms + 2, dataRear.dim2());
loadMetaData(firstEntry, instrumentPath);
std::vector<double> binningRear, binningRight, binningLeft, binningDown,
binningUp;
if (firstEntry.getFloat("mode") == 0.0) { // Not TOF
g_log.debug("Getting default wavelength bins...");
binningRear = m_defaultBinning;
binningRight = m_defaultBinning;
binningLeft = m_defaultBinning;
binningDown = m_defaultBinning;
binningUp = m_defaultBinning;
} else {
g_log.debug("Getting wavelength bins from the nexus file...");
std::string binPathPrefix(instrumentPath + "/tof/tof_wavelength_detector");
binningRear =
m_loader.getTimeBinningFromNexusPath(firstEntry, binPathPrefix + "1");
binningRight =
m_loader.getTimeBinningFromNexusPath(firstEntry, binPathPrefix + "2");
binningLeft =
m_loader.getTimeBinningFromNexusPath(firstEntry, binPathPrefix + "3");
binningDown =
m_loader.getTimeBinningFromNexusPath(firstEntry, binPathPrefix + "4");
binningUp =
m_loader.getTimeBinningFromNexusPath(firstEntry, binPathPrefix + "5");
}
g_log.debug("Loading the data into the workspace...");
size_t nextIndex = loadDataIntoWorkspaceFromMonitors(firstEntry, 0);
nextIndex = loadDataIntoWorkspaceFromHorizontalTubes(dataRear, binningRear,
nextIndex);
nextIndex = loadDataIntoWorkspaceFromVerticalTubes(dataRight, binningRight,
nextIndex);
nextIndex =
loadDataIntoWorkspaceFromVerticalTubes(dataLeft, binningLeft, nextIndex);
nextIndex = loadDataIntoWorkspaceFromHorizontalTubes(dataDown, binningDown,
nextIndex);
nextIndex =
loadDataIntoWorkspaceFromHorizontalTubes(dataUp, binningUp, nextIndex);
}
/**
* Load data found in nexus file
*
* @param entry :: The Nexus entry
* @param monitorsData :: Monitors data already loaded
*
*/
void LoadILLIndirect::loadDataIntoTheWorkSpace(
NeXus::NXEntry &entry, std::vector<std::vector<int>> monitorsData) {
// read in the data
NXData dataGroup = entry.openNXData("data");
NXInt data = dataGroup.openIntData();
// load the counts from the file into memory
data.load();
// Same for Simple Detectors
NXData dataSDGroup = entry.openNXData("dataSD");
NXInt dataSD = dataSDGroup.openIntData();
// load the counts from the file into memory
dataSD.load();
// Assign calculated bins to first X axis
//// m_localWorkspace->dataX(0).assign(detectorTofBins.begin(),
/// detectorTofBins.end());
size_t spec = 0;
size_t nb_monitors = monitorsData.size();
size_t nb_SD_detectors = dataSD.dim0();
Progress progress(this, 0, 1, m_numberOfTubes * m_numberOfPixelsPerTube +
nb_monitors + nb_SD_detectors);
// Assign fake values to first X axis <<to be completed>>
for (size_t i = 0; i <= m_numberOfChannels; ++i) {
m_localWorkspace->dataX(0)[i] = double(i);
}
// First, Monitor
for (size_t im = 0; im < nb_monitors; im++) {
if (im > 0) {
m_localWorkspace->dataX(im) = m_localWorkspace->readX(0);
}
// Assign Y
int *monitor_p = monitorsData[im].data();
m_localWorkspace->dataY(im)
.assign(monitor_p, monitor_p + m_numberOfChannels);
progress.report();
}
// Then Tubes
for (size_t i = 0; i < m_numberOfTubes; ++i) {
for (size_t j = 0; j < m_numberOfPixelsPerTube; ++j) {
// just copy the time binning axis to every spectra
m_localWorkspace->dataX(spec + nb_monitors) = m_localWorkspace->readX(0);
// Assign Y
int *data_p = &data(static_cast<int>(i), static_cast<int>(j), 0);
m_localWorkspace->dataY(spec + nb_monitors)
.assign(data_p, data_p + m_numberOfChannels);
// Assign Error
MantidVec &E = m_localWorkspace->dataE(spec + nb_monitors);
std::transform(data_p, data_p + m_numberOfChannels, E.begin(),
LoadILLIndirect::calculateError);
++spec;
progress.report();
}
} // for m_numberOfTubes
// Then add Simple Detector (SD)
for (int i = 0; i < dataSD.dim0(); ++i) {
// just copy again the time binning axis to every spectra
m_localWorkspace->dataX(spec + nb_monitors + i) =
m_localWorkspace->readX(0);
// Assign Y
int *dataSD_p = &dataSD(i, 0, 0);
m_localWorkspace->dataY(spec + nb_monitors + i)
.assign(dataSD_p, dataSD_p + m_numberOfChannels);
progress.report();
}
} // LoadILLIndirect::loadDataIntoTheWorkSpace