/**
* Read the bin masking information from the mantid_workspace_i/workspace group.
* @param wksp_cls :: The data group
* @param local_workspace :: The workspace to read into
*/
void LoadNexusProcessed::readBinMasking(NXData & wksp_cls, API::MatrixWorkspace_sptr local_workspace)
{
if (wksp_cls.getDataSetInfo("masked_spectra").stat == NX_ERROR)
{
return;
}
NXInt spec = wksp_cls.openNXInt("masked_spectra");
spec.load();
NXInt bins = wksp_cls.openNXInt("masked_bins");
bins.load();
NXDouble weights = wksp_cls.openNXDouble("mask_weights");
weights.load();
const int n = spec.dim0();
const int n1 = n - 1;
for(int i = 0; i < n; ++i)
{
int si = spec(i,0);
int j0 = spec(i,1);
int j1 = i < n1 ? spec(i+1,1) : bins.dim0();
for(int j = j0; j < j1; ++j)
{
local_workspace->flagMasked(si,bins[j],weights[j]);
}
}
}
/**
* 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());
}
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");
}
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;
}
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